Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/opencensus/common/backports/__init__.py

@@ -0,0 +1,79 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import six
+
+import weakref
+
+
+class WeakMethod(weakref.ref):  # pragma: NO COVER
+    """
+    A custom `weakref.ref` subclass which simulates a weak reference to
+    a bound method, working around the lifetime problem of bound methods.
+
+    This is a copy of the WeakMethod class that ships with weakref in the
+    python 3.7 standard library, adapted to work in 2.6. See:
+    https://github.com/python/cpython/blob/a31f4cc881992e84d351957bd9ac1a92f882fa39/Lib/weakref.py#L36-L87
+    """  # noqa
+
+    __slots__ = "_func_ref", "_meth_type", "_alive", "__weakref__"
+
+    def __new__(cls, meth, callback=None):
+        try:
+            obj = meth.__self__
+            func = meth.__func__
+        except AttributeError:
+            error = TypeError("argument should be a bound method, not {}"
+                              .format(type(meth)))
+            six.raise_from(error, None)
+
+        def _cb(arg):
+            # The self-weakref trick is needed to avoid creating a reference
+            # cycle.
+            self = self_wr()
+            if self._alive:
+                self._alive = False
+                if callback is not None:
+                    callback(self)
+        self = weakref.ref.__new__(cls, obj, _cb)
+        self._func_ref = weakref.ref(func, _cb)
+        self._meth_type = type(meth)
+        self._alive = True
+        self_wr = weakref.ref(self)
+        return self
+
+    def __call__(self):
+        obj = super(WeakMethod, self).__call__()
+        func = self._func_ref()
+        if obj is None or func is None:
+            return None
+        return self._meth_type(func, obj)
+
+    def __eq__(self, other):
+        if isinstance(other, WeakMethod):
+            if not self._alive or not other._alive:
+                return self is other
+            return (weakref.ref.__eq__(self, other)
+                    and self._func_ref == other._func_ref)
+        return False
+
+    def __ne__(self, other):
+        if isinstance(other, WeakMethod):
+            if not self._alive or not other._alive:
+                return self is not other
+            return (weakref.ref.__ne__(self, other)
+                    or self._func_ref != other._func_ref)
+        return True
+
+    __hash__ = weakref.ref.__hash__

.venv/lib/python3.11/site-packages/opencensus/common/configuration/__init__.py

@@ -0,0 +1,46 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import importlib
+
+__all__ = ['Namespace', 'load']
+
+
+class Namespace(object):
+    def __init__(self, name, parent=None):
+        self.parent = parent
+        self.name = name
+
+    def __getattr__(self, name):
+        return type(self)(name, self)
+
+    def __str__(self):
+        if self.parent is None:
+            return self.name
+        return '{!s}.{}'.format(self.parent, self.name)
+
+    def __call__(self, *args, **kwargs):
+        ctor = getattr(importlib.import_module(str(self.parent)), self.name)
+        return ctor(*args, **kwargs)
+
+    @classmethod
+    def eval(cls, expr):
+        return eval(expr, {}, {'opencensus': cls('opencensus')})
+
+
+def load(expr):
+    """Dynamically import OpenCensus components and evaluate the provided
+    configuration expression.
+    """
+    return Namespace.eval(expr)

.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/gcp_metadata_config.py

@@ -0,0 +1,115 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.common.http_handler import get_request
+
+_GCP_METADATA_URI = 'http://metadata.google.internal/computeMetadata/v1/'
+_GCP_METADATA_URI_HEADER = {'Metadata-Flavor': 'Google'}
+
+# ID of the GCP project associated with this resource, such as "my-project"
+PROJECT_ID_KEY = 'project_id'
+
+# Numeric VM instance identifier assigned by GCE
+INSTANCE_ID_KEY = 'instance_id'
+
+# The GCE zone in which the VM is running
+ZONE_KEY = 'zone'
+
+# GKE cluster name
+CLUSTER_NAME_KEY = 'instance/attributes/cluster-name'
+
+# GCE common attributes
+# See: https://cloud.google.com/appengine/docs/flexible/python/runtime#environment_variables  # noqa
+_GCE_ATTRIBUTES = {
+    PROJECT_ID_KEY: 'project/project-id',
+    INSTANCE_ID_KEY: 'instance/id',
+    ZONE_KEY: 'instance/zone'
+}
+
+_ATTRIBUTE_URI_TRANSFORMATIONS = {
+    _GCE_ATTRIBUTES[ZONE_KEY]:
+        lambda v: v[v.rfind('/') + 1:] if '/' in v else v
+}
+
+_GCP_METADATA_MAP = {}
+
+
+class GcpMetadataConfig(object):
+    """GcpMetadata represents metadata retrieved from GCP (GKE and GCE)
+    environment. Some attributes are retrieved from the system environment.
+    see : <a href="https://cloud.google.com/compute/docs/
+    storing-retrieving-metadata"> https://cloud.google.com/compute/docs/storing
+    -retrieving-metadata</a>
+    """
+    inited = False
+    is_running = False
+
+    @classmethod
+    def _initialize_metadata_service(cls):
+        """Initialize metadata service once and load gcp metadata into map
+        This method should only be called once.
+        """
+        if cls.inited:
+            return
+
+        instance_id = cls.get_attribute('instance/id')
+
+        if instance_id is not None:
+            cls.is_running = True
+
+            _GCP_METADATA_MAP['instance_id'] = instance_id
+
+            # fetch attributes from metadata request
+            for attribute_key, attribute_uri in _GCE_ATTRIBUTES.items():
+                if attribute_key not in _GCP_METADATA_MAP:
+                    attribute_value = cls.get_attribute(attribute_uri)
+                    if attribute_value is not None:  # pragma: NO COVER
+                        _GCP_METADATA_MAP[attribute_key] = attribute_value
+
+        cls.inited = True
+
+    @classmethod
+    def is_running_on_gcp(cls):
+        cls._initialize_metadata_service()
+        return cls.is_running
+
+    def get_gce_metadata(self):
+        """for GCP GCE instance"""
+        if self.is_running_on_gcp():
+            return _GCP_METADATA_MAP
+
+        return dict()
+
+    @staticmethod
+    def get_attribute(attribute_uri):
+        """
+        Fetch the requested instance metadata entry.
+        :param attribute_uri: attribute_uri: attribute name relative to the
+        computeMetadata/v1 prefix
+        :return:  The value read from the metadata service or None
+        """
+        attribute_value = get_request(_GCP_METADATA_URI + attribute_uri,
+                                      _GCP_METADATA_URI_HEADER)
+
+        if attribute_value is not None and isinstance(attribute_value, bytes):
+            # At least in python3, bytes are are returned from
+            # urllib (although the response is text), convert
+            # to a normal string:
+            attribute_value = attribute_value.decode('utf-8')
+
+        transformation = _ATTRIBUTE_URI_TRANSFORMATIONS.get(attribute_uri)
+        if transformation is not None:
+            attribute_value = transformation(attribute_value)
+
+        return attribute_value

.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/k8s_utils.py

@@ -0,0 +1,64 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+
+from opencensus.common.monitored_resource import gcp_metadata_config
+
+# Env var that signals that we're in a kubernetes container
+_KUBERNETES_SERVICE_HOST = 'KUBERNETES_SERVICE_HOST'
+
+# Name of the cluster the container is running in
+CLUSTER_NAME_KEY = 'k8s.io/cluster/name'
+
+# ID of the instance the container is running on
+NAMESPACE_NAME_KEY = 'k8s.io/namespace/name'
+
+# Container pod ID
+POD_NAME_KEY = 'k8s.io/pod/name'
+
+# Container name
+CONTAINER_NAME_KEY = 'k8s.io/container/name'
+
+# Attributes set from environment variables
+_K8S_ENV_ATTRIBUTES = {
+    CONTAINER_NAME_KEY: 'CONTAINER_NAME',
+    NAMESPACE_NAME_KEY: 'NAMESPACE',
+    POD_NAME_KEY: 'HOSTNAME'
+}
+
+
+def is_k8s_environment():
+    """Whether the environment is a kubernetes container.
+
+    The KUBERNETES_SERVICE_HOST environment variable must be set.
+    """
+    return _KUBERNETES_SERVICE_HOST in os.environ
+
+
+def get_k8s_metadata():
+    """Get kubernetes container metadata, as on GCP GKE."""
+    k8s_metadata = {}
+
+    gcp_cluster = (gcp_metadata_config.GcpMetadataConfig
+                   .get_attribute(gcp_metadata_config.CLUSTER_NAME_KEY))
+    if gcp_cluster is not None:
+        k8s_metadata[CLUSTER_NAME_KEY] = gcp_cluster
+
+    for attribute_key, attribute_env in _K8S_ENV_ATTRIBUTES.items():
+        attribute_value = os.environ.get(attribute_env)
+        if attribute_value is not None:
+            k8s_metadata[attribute_key] = attribute_value
+
+    return k8s_metadata

.venv/lib/python3.11/site-packages/opencensus/common/version/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = '0.11.4'

.venv/lib/python3.11/site-packages/opencensus/metrics/export/cumulative.py

@@ -0,0 +1,87 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import six
+
+from opencensus.metrics.export import gauge, metric_descriptor
+
+
+class CumulativePointLong(gauge.GaugePointLong):
+    """A `GaugePointLong` that cannot decrease."""
+
+    def _set(self, val):
+        if not isinstance(val, six.integer_types):
+            raise ValueError("CumulativePointLong only supports integer types")
+        if val > self.get_value():
+            super(CumulativePointLong, self)._set(val)
+
+    def add(self, val):
+        """Add `val` to the current value if it's positive.
+
+        Return without adding if `val` is not positive.
+
+        :type val: int
+        :param val: Value to add.
+        """
+        if not isinstance(val, six.integer_types):
+            raise ValueError("CumulativePointLong only supports integer types")
+        if val > 0:
+            super(CumulativePointLong, self).add(val)
+
+
+class CumulativePointDouble(gauge.GaugePointDouble):
+    """A `GaugePointDouble` that cannot decrease."""
+
+    def _set(self, val):
+        if val > self.get_value():
+            super(CumulativePointDouble, self)._set(val)
+
+    def add(self, val):
+        """Add `val` to the current value if it's positive.
+
+        Return without adding if `val` is not positive.
+
+        :type val: float
+        :param val: Value to add.
+        """
+        if val > 0:
+            super(CumulativePointDouble, self).add(val)
+
+
+class LongCumulativeMixin(object):
+    """Type mixin for long-valued cumulative measures."""
+    descriptor_type = metric_descriptor.MetricDescriptorType.CUMULATIVE_INT64
+    point_type = CumulativePointLong
+
+
+class DoubleCumulativeMixin(object):
+    """Type mixin for float-valued cumulative measures."""
+    descriptor_type = metric_descriptor.MetricDescriptorType.CUMULATIVE_DOUBLE
+    point_type = CumulativePointDouble
+
+
+class LongCumulative(LongCumulativeMixin, gauge.Gauge):
+    """Records cumulative int-valued measurements."""
+
+
+class DoubleCumulative(DoubleCumulativeMixin, gauge.Gauge):
+    """Records cumulative float-valued measurements."""
+
+
+class DerivedLongCumulative(LongCumulativeMixin, gauge.DerivedGauge):
+    """Records derived cumulative int-valued measurements."""
+
+
+class DerivedDoubleCumulative(DoubleCumulativeMixin, gauge.DerivedGauge):
+    """Records derived cumulative float-valued measurements."""

.venv/lib/python3.11/site-packages/opencensus/metrics/export/gauge.py

@@ -0,0 +1,513 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import six
+
+import threading
+from collections import OrderedDict
+from datetime import datetime
+
+from opencensus.common import utils
+from opencensus.metrics.export import (
+    metric,
+    metric_descriptor,
+    metric_producer,
+)
+from opencensus.metrics.export import point as point_module
+from opencensus.metrics.export import time_series
+from opencensus.metrics.export import value as value_module
+
+
+def get_timeseries_list(points, timestamp):
+    """Convert a list of `GaugePoint`s into a list of `TimeSeries`.
+
+    Get a :class:`opencensus.metrics.export.time_series.TimeSeries` for each
+    measurement in `points`. Each series contains a single
+    :class:`opencensus.metrics.export.point.Point` that represents the last
+    recorded value of the measurement.
+
+    :type points: list(:class:`GaugePoint`)
+    :param points: The list of measurements to convert.
+
+    :type timestamp: :class:`datetime.datetime`
+    :param timestamp: Recording time to report, usually the current time.
+
+    :rtype: list(:class:`opencensus.metrics.export.time_series.TimeSeries`)
+    :return: A list of one `TimeSeries` for each point in `points`.
+    """
+    ts_list = []
+    for lv, gp in points.items():
+        point = point_module.Point(gp.to_point_value(), timestamp)
+        ts_list.append(time_series.TimeSeries(lv, [point], timestamp))
+    return ts_list
+
+
+class GaugePoint(object):
+
+    def to_point_value(self):
+        raise NotImplementedError  # pragma: NO COVER
+
+    def get_value(self):
+        raise NotImplementedError  # pragma: NO COVER
+
+
+class GaugePointLong(GaugePoint):
+    """An instantaneous measurement from a LongGauge.
+
+    A GaugePointLong represents the most recent measurement from a
+    :class:`LongGauge` for a given set of label values.
+    """
+
+    def __init__(self):
+        self.value = 0
+        self._value_lock = threading.Lock()
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.value
+                ))
+
+    def add(self, val):
+        """Add `val` to the current value.
+
+        :type val: int
+        :param val: Value to add.
+        """
+        if not isinstance(val, six.integer_types):
+            raise ValueError("GaugePointLong only supports integer types")
+        with self._value_lock:
+            self.value += val
+
+    def _set(self, val):
+        if not isinstance(val, six.integer_types):
+            raise ValueError("GaugePointLong only supports integer types")
+        with self._value_lock:
+            self.value = val
+
+    def set(self, val):
+        """Set the current value to `val`.
+
+        :type val: int
+        :param val: Value to set.
+        """
+        self._set(val)
+
+    def get_value(self):
+        """Get the current value.
+
+        :rtype: int
+        :return: The current value of the measurement.
+        """
+        return self.value
+
+    def to_point_value(self):
+        """Get a point value conversion of the current value.
+
+        :rtype: :class:`opencensus.metrics.export.value.ValueLong`
+        :return: A converted `ValueLong`.
+        """
+        return value_module.ValueLong(self.value)
+
+
+class GaugePointDouble(GaugePoint):
+    """An instantaneous measurement from a DoubleGauge.
+
+    A `GaugePointDouble` represents the most recent measurement from a
+    :class:`DoubleGauge` for a given set of label values.
+    """
+
+    def __init__(self):
+        self.value = 0.0
+        self._value_lock = threading.Lock()
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.value
+                ))
+
+    def add(self, val):
+        """Add `val` to the current value.
+
+        :type val: float
+        :param val: Value to add.
+        """
+        with self._value_lock:
+            self.value += val
+
+    def _set(self, val):
+        with self._value_lock:
+            self.value = float(val)
+
+    def set(self, val):
+        """Set the current value to `val`.
+
+        :type val: float
+        :param val: Value to set.
+        """
+        self._set(val)
+
+    def get_value(self):
+        """Get the current value.
+
+        :rtype: float
+        :return: The current value of the measurement.
+        """
+        return self.value
+
+    def to_point_value(self):
+        """Get a point value conversion of the current value.
+
+        :rtype: :class:`opencensus.metrics.export.value.ValueDouble`
+        :return: A converted `ValueDouble`.
+        """
+        return value_module.ValueDouble(self.value)
+
+
+class DerivedGaugePoint(GaugePoint):
+    """Wraps a `GaugePoint` to automatically track the value of a function.
+
+    A `DerivedGaugePoint` is a read-only measure that stores the most recently
+    read value of a given function in a mutable `GaugePoint`. Calling
+    `get_value` or `to_point_value` calls the tracked function and updates the
+    wrapped `GaugePoint`.
+
+    :type func: function
+    :param func: The function to track.
+
+    :type gauge_point: :class:`GaugePointLong`, :class:`GaugePointDouble`,
+        :class:`opencensus.metrics.export.cumulative.CumulativePointLong`, or
+        :class:`opencensus.metrics.export.cumulative.CumulativePointDouble`
+    :param gauge_point: The underlying `GaugePoint`.
+    """
+    def __init__(self, func, gauge_point, **kwargs):
+        self.gauge_point = gauge_point
+        self.func = utils.get_weakref(func)
+        self._kwargs = kwargs
+
+    def __repr__(self):
+        return ("{}({})({})"
+                .format(
+                    type(self).__name__,
+                    self.func(),
+                    self._kwargs
+                ))
+
+    def get_value(self):
+        """Get the current value of the underlying measurement.
+
+        Calls the tracked function and stores the value in the wrapped
+        measurement as a side-effect.
+
+        :rtype: int, float, or None
+        :return: The current value of the wrapped function, or `None` if it no
+            longer exists.
+        """
+        try:
+            val = self.func()(**self._kwargs)
+        except TypeError:  # The underlying function has been GC'd
+            return None
+
+        self.gauge_point._set(val)
+        return self.gauge_point.get_value()
+
+    def to_point_value(self):
+        """Get a point value conversion of the current value.
+
+        Calls the tracked function and stores the value in the wrapped
+        measurement as a side-effect.
+
+        :rtype: :class:`opencensus.metrics.export.value.ValueLong`,
+            :class:`opencensus.metrics.export.value.ValueDouble`, or None
+        :return: The point value conversion of the underlying `GaugePoint`, or
+            None if the tracked function no longer exists.
+        """
+        if self.get_value() is None:
+            return None
+        return self.gauge_point.to_point_value()
+
+
+class BaseGauge(object):
+    """Base class for sets instantaneous measurements."""
+
+    def __init__(self, name, description, unit, label_keys):
+        self._len_label_keys = len(label_keys)
+        self.default_label_values = [None] * self._len_label_keys
+        self.descriptor = metric_descriptor.MetricDescriptor(
+            name, description, unit, self.descriptor_type, label_keys)
+        self.points = OrderedDict()
+        self._points_lock = threading.Lock()
+
+    def __repr__(self):
+        return ('{}(descriptor.name="{}", points={})'
+                .format(
+                    type(self).__name__,
+                    self.descriptor.name,
+                    self.points
+                ))
+
+    def _remove_time_series(self, label_values):
+        with self._points_lock:
+            try:
+                del self.points[tuple(label_values)]
+            except KeyError:
+                pass
+
+    def remove_time_series(self, label_values):
+        """Remove the time series for specific label values.
+
+        :type label_values: list(:class:`LabelValue`)
+        :param label_values: Label values of the time series to remove.
+        """
+        if label_values is None:
+            raise ValueError
+        if any(lv is None for lv in label_values):
+            raise ValueError
+        if len(label_values) != self._len_label_keys:
+            raise ValueError
+        self._remove_time_series(label_values)
+
+    def remove_default_time_series(self):
+        """Remove the default time series for this gauge."""
+        self._remove_time_series(self.default_label_values)
+
+    def clear(self):
+        """Remove all points from this gauge."""
+        with self._points_lock:
+            self.points = OrderedDict()
+
+    def get_metric(self, timestamp):
+        """Get a metric including all current time series.
+
+        Get a :class:`opencensus.metrics.export.metric.Metric` with one
+        :class:`opencensus.metrics.export.time_series.TimeSeries` for each
+        set of label values with a recorded measurement. Each `TimeSeries`
+        has a single point that represents the last recorded value.
+
+        :type timestamp: :class:`datetime.datetime`
+        :param timestamp: Recording time to report, usually the current time.
+
+        :rtype: :class:`opencensus.metrics.export.metric.Metric` or None
+        :return: A converted metric for all current measurements.
+        """
+        if not self.points:
+            return None
+
+        with self._points_lock:
+            ts_list = get_timeseries_list(self.points, timestamp)
+        return metric.Metric(self.descriptor, ts_list)
+
+    @property
+    def descriptor_type(self):  # pragma: NO COVER
+        raise NotImplementedError
+
+    @property
+    def point_type(self):  # pragma: NO COVER
+        raise NotImplementedError
+
+
+class Gauge(BaseGauge):
+    """A set of mutable, instantaneous measurements of the same type.
+
+    End users should use :class:`LongGauge`, :class:`DoubleGauge`,
+    :class:`opencensus.metrics.export.cumulative.LongCumulative`, or
+    :class:`opencensus.metrics.export.cumulative.DoubleCumulative` instead of
+    using this class directly.
+
+    The constructor arguments are used to create a
+    :class:`opencensus.metrics.export.metric_descriptor.MetricDescriptor` for
+    converted metrics. See that class for details.
+    """
+
+    def _get_or_create_time_series(self, label_values):
+        with self._points_lock:
+            return self.points.setdefault(
+                tuple(label_values), self.point_type())
+
+    def get_or_create_time_series(self, label_values):
+        """Get a mutable measurement for the given set of label values.
+
+        :type label_values: list(:class:`LabelValue`)
+        :param label_values: The measurement's label values.
+
+        :rtype: :class:`GaugePointLong`, :class:`GaugePointDouble`
+            :class:`opencensus.metrics.export.cumulative.CumulativePointLong`,
+            or
+            :class:`opencensus.metrics.export.cumulative.CumulativePointDouble`
+        :return: A mutable point that represents the last value of the
+            measurement.
+        """
+        if label_values is None:
+            raise ValueError
+        if any(lv is None for lv in label_values):
+            raise ValueError
+        if len(label_values) != self._len_label_keys:
+            raise ValueError
+        return self._get_or_create_time_series(label_values)
+
+    def get_or_create_default_time_series(self):
+        """Get the default measurement for this gauge.
+
+        Each gauge has a default point not associated with any specific label
+        values. When this gauge is exported as a metric via `get_metric` the
+        time series associated with this point will have null label values.
+
+        :rtype: :class:`GaugePointLong`, :class:`GaugePointDouble`
+            :class:`opencensus.metrics.export.cumulative.CumulativePointLong`,
+            or
+            :class:`opencensus.metrics.export.cumulative.CumulativePointDouble`
+        :return: A mutable point that represents the last value of the
+            measurement.
+        """
+        return self._get_or_create_time_series(self.default_label_values)
+
+
+class LongGaugeMixin(object):
+    """Type mixin for long-valued gauges."""
+    descriptor_type = metric_descriptor.MetricDescriptorType.GAUGE_INT64
+    point_type = GaugePointLong
+
+
+class DoubleGaugeMixin(object):
+    """Type mixin for float-valued gauges."""
+    descriptor_type = metric_descriptor.MetricDescriptorType.GAUGE_DOUBLE
+    point_type = GaugePointDouble
+
+
+class LongGauge(LongGaugeMixin, Gauge):
+    """Gauge for recording int-valued measurements."""
+
+
+class DoubleGauge(DoubleGaugeMixin, Gauge):
+    """Gauge for recording float-valued measurements."""
+
+
+class DerivedGauge(BaseGauge):
+    """Gauge that tracks values of other functions.
+
+    Each of a `DerivedGauge`'s measurements are associated with a function
+    which is called when the gauge is exported.
+
+    End users should use :class:`DerivedLongGauge`, :class:`DerivedDoubleGauge`
+    :class:`opencensus.metrics.export.cumulative.DerivedLongCumulative`, or
+    :class:`opencensus.metrics.export.cumulative.DerivedDoubleCumulative`
+    instead of using this class directly.
+    """
+
+    def _create_time_series(self, label_values, func, **kwargs):
+        with self._points_lock:
+            return self.points.setdefault(
+                tuple(label_values),
+                DerivedGaugePoint(func, self.point_type(), **kwargs))
+
+    def create_time_series(self, label_values, func, **kwargs):
+        """Create a derived measurement to trac `func`.
+
+        :type label_values: list(:class:`LabelValue`)
+        :param label_values: The measurement's label values.
+
+        :type func: function
+        :param func: The function to track.
+
+        :rtype: :class:`DerivedGaugePoint`
+        :return: A read-only measurement that tracks `func`.
+        """
+        if label_values is None:
+            raise ValueError
+        if any(lv is None for lv in label_values):
+            raise ValueError
+        if len(label_values) != self._len_label_keys:
+            raise ValueError
+        if func is None:
+            raise ValueError
+        return self._create_time_series(label_values, func, **kwargs)
+
+    def create_default_time_series(self, func):
+        """Create the default derived measurement for this gauge.
+
+        :type func: function
+        :param func: The function to track.
+
+        :rtype: :class:`DerivedGaugePoint`
+        :return: A read-only measurement that tracks `func`.
+        """
+        if func is None:
+            raise ValueError
+        return self._create_time_series(self.default_label_values, func)
+
+
+class DerivedLongGauge(LongGaugeMixin, DerivedGauge):
+    """Gauge for derived int-valued measurements."""
+
+
+class DerivedDoubleGauge(DoubleGaugeMixin, DerivedGauge):
+    """Gauge for derived float-valued measurements."""
+
+
+class Registry(metric_producer.MetricProducer):
+    """A collection of gauges to be exported together.
+
+    Each registered gauge must have a unique `descriptor.name`.
+    """
+
+    def __init__(self):
+        self.gauges = {}
+        self._gauges_lock = threading.Lock()
+
+    def __repr__(self):
+        return ('{}(gauges={}'
+                .format(
+                    type(self).__name__,
+                    self.gauges
+                ))
+
+    def add_gauge(self, gauge):
+        """Add `gauge` to the registry.
+
+        Raises a `ValueError` if another gauge with the same name already
+        exists in the registry.
+
+        :type gauge: class:`LongGauge`, class:`DoubleGauge`,
+            :class:`opencensus.metrics.export.cumulative.LongCumulative`,
+            :class:`opencensus.metrics.export.cumulative.DoubleCumulative`,
+            :class:`DerivedLongGauge`, :class:`DerivedDoubleGauge`
+            :class:`opencensus.metrics.export.cumulative.DerivedLongCumulative`,
+            or
+            :class:`opencensus.metrics.export.cumulative.DerivedDoubleCumulative`
+        :param gauge: The gauge to add to the registry.
+        """
+        if gauge is None:
+            raise ValueError
+        name = gauge.descriptor.name
+        with self._gauges_lock:
+            if name in self.gauges:
+                raise ValueError(
+                    'Another gauge named "{}" is already registered'
+                    .format(name))
+            self.gauges[name] = gauge
+
+    def get_metrics(self):
+        """Get a metric for each gauge in the registry at the current time.
+
+        :rtype: set(:class:`opencensus.metrics.export.metric.Metric`)
+        :return: A set of `Metric`s, one for each registered gauge.
+        """
+        now = datetime.utcnow()
+        metrics = set()
+        for gauge in self.gauges.values():
+            metrics.add(gauge.get_metric(now))
+        return metrics

.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric.py

@@ -0,0 +1,79 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from opencensus.metrics.export import metric_descriptor
+
+
+class Metric(object):
+    """A collection of time series data and label metadata.
+
+    This class implements the spec for v1 Metrics as of opencensus-proto
+    release v0.1.0. See opencensus-proto for details:
+
+    https://github.com/census-instrumentation/opencensus-proto/blob/v0.1.0/src/opencensus/proto/metrics/v1/metrics.proto#L35
+
+    Defines a Metric which has one or more timeseries.
+
+    :type descriptor: class: '~opencensus.metrics.export.metric_descriptor.MetricDescriptor'
+    :param descriptor: The metric's descriptor.
+
+    :type timeseries: list(:class: '~opencensus.metrics.export.time_series.TimeSeries')
+    :param timeseries: One or more timeseries for a single metric, where each
+    timeseries has one or more points.
+    """  # noqa
+
+    def __init__(self, descriptor, time_series):
+        if not time_series:
+            raise ValueError("time_series must not be empty or null")
+        if descriptor is None:
+            raise ValueError("descriptor must not be null")
+        self._time_series = time_series
+        self._descriptor = descriptor
+        self._check_type()
+
+    def __repr__(self):
+        return ('{}(time_series={}, descriptor.name="{}")'
+                .format(
+                    type(self).__name__,
+                    "<{} TimeSeries>".format(len(self.time_series)),
+                    self.descriptor.name,
+                ))
+
+    @property
+    def time_series(self):
+        return self._time_series
+
+    @property
+    def descriptor(self):
+        return self._descriptor
+
+    def _check_type(self):
+        """Check that point value types match the descriptor type."""
+        check_type = metric_descriptor.MetricDescriptorType.to_type_class(
+            self.descriptor.type)
+        for ts in self.time_series:
+            if not ts.check_points_type(check_type):
+                raise ValueError("Invalid point value type")
+
+    def _check_start_timestamp(self):
+        """Check that starting timestamp exists for cumulative metrics."""
+        if self.descriptor.type in (
+                metric_descriptor.MetricDescriptorType.CUMULATIVE_INT64,
+                metric_descriptor.MetricDescriptorType.CUMULATIVE_DOUBLE,
+                metric_descriptor.MetricDescriptorType.CUMULATIVE_DISTRIBUTION,
+        ):
+            for ts in self.time_series:
+                if ts.start_timestamp is None:
+                    raise ValueError("time_series.start_timestamp must exist "
+                                     "for cumulative metrics")

.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric_descriptor.py

@@ -0,0 +1,174 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import six
+
+from opencensus.metrics.export import value
+
+
+class _MetricDescriptorTypeMeta(type):
+    """Helper for `x in MetricDescriptorType`."""
+
+    def __contains__(cls, item):
+        return item in {
+            MetricDescriptorType.GAUGE_INT64,
+            MetricDescriptorType.GAUGE_DOUBLE,
+            MetricDescriptorType.GAUGE_DISTRIBUTION,
+            MetricDescriptorType.CUMULATIVE_INT64,
+            MetricDescriptorType.CUMULATIVE_DOUBLE,
+            MetricDescriptorType.CUMULATIVE_DISTRIBUTION
+        }
+
+
+@six.add_metaclass(_MetricDescriptorTypeMeta)
+class MetricDescriptorType(object):
+    """The kind of metric. It describes how the data is reported.
+
+    MetricDescriptorType is an enum of valid MetricDescriptor type values. See
+    opencensus-proto for details:
+
+    https://github.com/census-instrumentation/opencensus-proto/blob/v0.1.0/src/opencensus/proto/metrics/v1/metrics.proto#L79
+
+    A gauge is an instantaneous measurement of a value.
+
+    A cumulative measurement is a value accumulated over a time interval. In a
+    time series, cumulative measurements should have the same start time and
+    increasing end times, until an event resets the cumulative value to zero
+    and sets a new start time for the following points.
+
+    """
+    # Integer gauge. The value can go both up and down.
+    GAUGE_INT64 = 1
+
+    # Floating point gauge. The value can go both up and down.
+    GAUGE_DOUBLE = 2
+
+    # Distribution gauge measurement. The count and sum can go both up and
+    # down. Recorded values are always >= 0.
+    # Used in scenarios like a snapshot of time the current items in a queue
+    # have spent there.
+    GAUGE_DISTRIBUTION = 3
+
+    # Integer cumulative measurement. The value cannot decrease, if resets then
+    # the start_time should also be reset.
+    CUMULATIVE_INT64 = 4
+
+    # Floating point cumulative measurement. The value cannot decrease, if
+    # resets then the start_time should also be reset. Recorded values are
+    # always >= 0.
+    CUMULATIVE_DOUBLE = 5
+
+    # Distribution cumulative measurement. The count and sum cannot decrease,
+    # if resets then the start_time should also be reset.
+    CUMULATIVE_DISTRIBUTION = 6
+
+    # Some frameworks implemented Histograms as a summary of observations
+    # (usually things like request durations and response sizes). While it also
+    # provides a total count of observations and a sum of all observed values,
+    # it calculates configurable percentiles over a sliding time window. This
+    # is not recommended, since it cannot be aggregated.
+    SUMMARY = 7
+
+    _type_map = {
+        GAUGE_INT64: value.ValueLong,
+        GAUGE_DOUBLE: value.ValueDouble,
+        GAUGE_DISTRIBUTION: value.ValueDistribution,
+        CUMULATIVE_INT64: value.ValueLong,
+        CUMULATIVE_DOUBLE: value.ValueDouble,
+        CUMULATIVE_DISTRIBUTION: value.ValueDistribution,
+        SUMMARY: value.ValueSummary
+    }
+
+    @classmethod
+    def to_type_class(cls, metric_descriptor_type):
+        try:
+            return cls._type_map[metric_descriptor_type]
+        except KeyError:
+            raise ValueError("Unknown MetricDescriptorType value")
+
+
+class MetricDescriptor(object):
+    """Defines a metric type and its schema.
+
+    This class implements the spec for v1 MetricDescriptors, as of
+    opencensus-proto release v0.1.0. See opencensus-proto for details:
+
+    https://github.com/census-instrumentation/opencensus-proto/blob/v0.1.0/src/opencensus/proto/metrics/v1/metrics.proto#L59
+
+    :type name: str
+    :param name: The metric type, including its DNS name prefix. It must be
+    unique.
+
+    :type description: str
+    :param description: A detailed description of the metric, which can be used
+    in documentation.
+
+    :type unit: str
+    :param unit: The unit in which the metric value is reported. Follows the
+    format described by http://unitsofmeasure.org/ucum.html.
+
+    :type type_: int
+    :param type_: The type of metric. MetricDescriptorType enumerates the valid
+    options.
+
+    :type label_keys: list(:class: '~opencensus.metrics.label_key.LabelKey')
+    :param label_keys: The label keys associated with the metric descriptor.
+    """
+
+    def __init__(self, name, description, unit, type_, label_keys):
+        if type_ not in MetricDescriptorType:
+            raise ValueError("Invalid type")
+
+        if label_keys is None:
+            raise ValueError("label_keys must not be None")
+
+        if any(key is None for key in label_keys):
+            raise ValueError("label_keys must not contain null keys")
+
+        self._name = name
+        self._description = description
+        self._unit = unit
+        self._type = type_
+        self._label_keys = label_keys
+
+    def __repr__(self):
+        type_name = MetricDescriptorType.to_type_class(self.type).__name__
+        return ('{}(name="{}", description="{}", unit={}, type={})'
+                .format(
+                    type(self).__name__,
+                    self.name,
+                    self.description,
+                    self.unit,
+                    type_name,
+                ))
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def description(self):
+        return self._description
+
+    @property
+    def unit(self):
+        return self._unit
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def label_keys(self):
+        return self._label_keys

.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric_producer.py

@@ -0,0 +1,81 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import threading
+
+
+class MetricProducer(object):
+    """Produces a set of metrics for export."""
+
+    def get_metrics(self):
+        """Get a set of metrics to be exported.
+
+        :rtype: set(:class: `opencensus.metrics.export.metric.Metric`)
+        :return: A set of metrics to be exported.
+        """
+        raise NotImplementedError  # pragma: NO COVER
+
+
+class MetricProducerManager(object):
+    """Container class for MetricProducers to be used by exporters.
+
+    :type metric_producers: iterable(class: 'MetricProducer')
+    :param metric_producers: Optional initial metric producers.
+    """
+
+    def __init__(self, metric_producers=None):
+        if metric_producers is None:
+            self.metric_producers = set()
+        else:
+            self.metric_producers = set(metric_producers)
+        self.mp_lock = threading.Lock()
+
+    def add(self, metric_producer):
+        """Add a metric producer.
+
+        :type metric_producer: :class: 'MetricProducer'
+        :param metric_producer: The metric producer to add.
+        """
+        if metric_producer is None:
+            raise ValueError
+        with self.mp_lock:
+            self.metric_producers.add(metric_producer)
+
+    def remove(self, metric_producer):
+        """Remove a metric producer.
+
+        :type metric_producer: :class: 'MetricProducer'
+        :param metric_producer: The metric producer to remove.
+        """
+        if metric_producer is None:
+            raise ValueError
+        try:
+            with self.mp_lock:
+                self.metric_producers.remove(metric_producer)
+        except KeyError:
+            pass
+
+    def get_all(self):
+        """Get the set of all metric producers.
+
+        Get a copy of `metric_producers`. Prefer this method to using the
+        attribute directly to avoid other threads adding/removing producers
+        while you're reading it.
+
+        :rtype: set(:class: `MetricProducer`)
+        :return: A set of all metric producers at the time of the call.
+        """
+        with self.mp_lock:
+            mps_copy = set(self.metric_producers)
+        return mps_copy

.venv/lib/python3.11/site-packages/opencensus/metrics/export/point.py

@@ -0,0 +1,47 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Point(object):
+    """A timestamped measurement of a TimeSeries.
+
+    :type value: :class:`opencensus.metrics.export.value.ValueDouble` or
+        :class:`opencensus.metrics.export.value.ValueLong` or
+        :class:`opencensus.metrics.export.value.ValueSummary` or
+        :class:`opencensus.metrics.export.value.ValueDistribution`
+    :param value: the point value.
+
+    :type timestamp: time
+    :param timestamp: the timestamp when the `Point` was recorded.
+    """
+
+    def __init__(self, value, timestamp):
+        self._value = value
+        self._timestamp = timestamp
+
+    @property
+    def value(self):
+        return self._value
+
+    @property
+    def timestamp(self):
+        return self._timestamp
+
+    def __repr__(self):
+        return ("{}(value={}, timestamp={})"
+                .format(
+                    type(self).__name__,
+                    self.value,
+                    self.timestamp
+                ))

.venv/lib/python3.11/site-packages/opencensus/metrics/export/summary.py

@@ -0,0 +1,144 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class Summary(object):
+    """Implementation of the Summary as a summary of observations.
+
+    :type count: long
+    :param count: the count of the population values.
+
+    :type sum_data: float
+    :param sum_data: the sum of the population values.
+
+    :type snapshot: Snapshot
+    :param snapshot: the values calculated over a sliding time window.
+    """
+
+    def __init__(self, count, sum_data, snapshot):
+        check_count_and_sum(count, sum_data)
+        self._count = count
+        self._sum_data = sum_data
+
+        if snapshot is None:
+            raise ValueError('snapshot must not be none')
+
+        self._snapshot = snapshot
+
+    @property
+    def count(self):
+        """Returns the count of the population values"""
+        return self._count
+
+    @property
+    def sum_data(self):
+        """Returns the sum of the population values."""
+        return self._sum_data
+
+    @property
+    def snapshot(self):
+        """Returns the values calculated over a sliding time window."""
+        return self._snapshot
+
+
+class Snapshot(object):
+    """Represents the summary observation of the recorded events over a
+    sliding time window.
+
+    :type count: long
+    :param count: the number of values in the snapshot.
+
+    :type sum_data: float
+    :param sum_data: the sum of values in the snapshot.
+
+    :type value_at_percentiles: ValueAtPercentile
+    :param value_at_percentiles: a list of values at different percentiles
+    of the distribution calculated from the current snapshot. The percentiles
+    must be strictly increasing.
+    """
+
+    def __init__(self, count, sum_data, value_at_percentiles=None):
+        check_count_and_sum(count, sum_data)
+        self._count = count
+        self._sum_data = sum_data
+
+        if value_at_percentiles is None:
+            value_at_percentiles = []
+
+        if not isinstance(value_at_percentiles, list):
+            raise ValueError('value_at_percentiles must be an '
+                             'instance of list')
+
+        self._value_at_percentiles = value_at_percentiles
+
+    @property
+    def count(self):
+        """Returns the number of values in the snapshot"""
+        return self._count
+
+    @property
+    def sum_data(self):
+        """Returns the sum of values in the snapshot."""
+        return self._sum_data
+
+    @property
+    def value_at_percentiles(self):
+        """Returns a list of values at different percentiles
+        of the distribution calculated from the current snapshot.
+        """
+        return self._value_at_percentiles
+
+
+class ValueAtPercentile(object):
+    """Represents the value at a given percentile of a distribution.
+
+    :type percentile: float
+    :param percentile: the percentile in the ValueAtPercentile.
+
+    :type value: float
+    :param value: the value in the ValueAtPercentile.
+    """
+
+    def __init__(self, percentile, value):
+
+        if not 0 < percentile <= 100.0:
+            raise ValueError("percentile must be in the interval (0.0, 100.0]")
+
+        self._percentile = percentile
+
+        if value < 0:
+            raise ValueError('value must be non-negative')
+
+        self._value = value
+
+    @property
+    def percentile(self):
+        """Returns the percentile in the ValueAtPercentile"""
+        return self._percentile
+
+    @property
+    def value(self):
+        """Returns the value in the ValueAtPercentile"""
+        return self._value
+
+
+def check_count_and_sum(count, sum_data):
+    if not (count is None or count >= 0):
+        raise ValueError('count must be non-negative')
+
+    if not (sum_data is None or sum_data >= 0):
+        raise ValueError('sum_data must be non-negative')
+
+    if count == 0 and sum_data != 0:
+        raise ValueError('sum_data must be 0 if count is 0')

.venv/lib/python3.11/site-packages/opencensus/metrics/export/time_series.py

@@ -0,0 +1,90 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class TimeSeries(object):
+    """Time series data for a given metric and time interval.
+
+    This class implements the spec for v1 TimeSeries structs as of
+    opencensus-proto release v0.1.0. See opencensus-proto for details:
+
+        https://github.com/census-instrumentation/opencensus-proto/blob/v0.1.0/src/opencensus/proto/metrics/v1/metrics.proto#L132
+
+    A TimeSeries is a collection of data points that describes the time-varying
+    values of a metric.
+
+    :type label_values: list(:class:
+    '~opencensus.metrics.label_value.LabelValue')
+    :param label_values: The set of label values that uniquely identify this
+    timeseries.
+
+    :type points: list(:class: '~opencensus.metrics.export.point.Point')
+    :param points: The data points of this timeseries.
+
+    :type start_timestamp: str
+    :param start_timestamp: The time when the cumulative value was reset to
+    zero, must be set for cumulative metrics.
+    """  # noqa
+
+    def __init__(self, label_values, points, start_timestamp):
+        if label_values is None:
+            raise ValueError("label_values must not be None")
+        if not points:
+            raise ValueError("points must not be null or empty")
+        self._label_values = label_values
+        self._points = points
+        self._start_timestamp = start_timestamp
+
+    def __repr__(self):
+        points_repr = '[{}]'.format(
+            ', '.join(repr(point.value) for point in self.points))
+
+        lv_repr = tuple(lv.value for lv in self.label_values)
+        return ('{}({}, label_values={}, start_timestamp={})'
+                .format(
+                    type(self).__name__,
+                    points_repr,
+                    lv_repr,
+                    self.start_timestamp
+                ))
+
+    @property
+    def start_timestamp(self):
+        return self._start_timestamp
+
+    @property
+    def label_values(self):
+        return self._label_values
+
+    @property
+    def points(self):
+        return self._points
+
+    def check_points_type(self, type_class):
+        """Check that each point's value is an instance of `type_class`.
+
+        `type_class` should typically be a Value type, i.e. one that extends
+        :class: `opencensus.metrics.export.value.Value`.
+
+        :type type_class: type
+        :param type_class: Type to check against.
+
+        :rtype: bool
+        :return: Whether all points are instances of `type_class`.
+        """
+        for point in self.points:
+            if (point.value is not None
+                    and not isinstance(point.value, type_class)):
+                return False
+        return True

.venv/lib/python3.11/site-packages/opencensus/metrics/export/value.py

@@ -0,0 +1,307 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+The classes in this module implement the spec for v1 Metrics as of
+opencensus-proto release v0.1.0. See opencensus-proto for details:
+
+https://github.com/census-instrumentation/opencensus-proto/blob/v0.1.0/src/opencensus/proto/metrics/v1/metrics.proto
+"""  # noqa
+
+from copy import copy
+
+
+class ValueDouble(object):
+    """A 64-bit double-precision floating-point number.
+
+    :type value: float
+    :param value: the value in float.
+    """
+
+    def __init__(self, value):
+        self._value = value
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.value,
+                ))
+
+    @property
+    def value(self):
+        return self._value
+
+
+class ValueLong(object):
+    """A 64-bit integer.
+
+    :type value: long
+    :param value: the value in long.
+    """
+
+    def __init__(self, value):
+        self._value = value
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.value,
+                ))
+
+    @property
+    def value(self):
+        return self._value
+
+
+class ValueSummary(object):
+    """Represents a snapshot values calculated over an arbitrary time window.
+
+    :type value: summary
+    :param value: the value in summary.
+    """
+
+    def __init__(self, value):
+        self._value = value
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.value,
+                ))
+
+    @property
+    def value(self):
+        return self._value
+
+
+class Exemplar(object):
+    """An example point to annotate a given value in a bucket.
+
+    Exemplars are example points that may be used to annotate aggregated
+    Distribution values. They are metadata that gives information about a
+    particular value added to a Distribution bucket.
+
+    :type value: double
+    :param value: Value of the exemplar point, determines which bucket the
+    exemplar belongs to.
+
+    :type timestamp: str
+    :param timestamp: The observation (sampling) time of the exemplar value.
+
+    :type attachments: dict(str, str)
+    :param attachments: Contextual information about the example value.
+    """
+
+    def __init__(self, value, timestamp, attachments):
+        self._value = value
+        self._timestamp = timestamp
+        self._attachments = attachments
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.value,
+                ))
+
+    @property
+    def value(self):
+        return self._value
+
+    @property
+    def timestamp(self):
+        return self._timestamp
+
+    @property
+    def attachments(self):
+        return self._attachments
+
+
+class Bucket(object):
+    """A bucket of a histogram.
+
+    :type count: int
+    :param count: The number of values in each bucket of the histogram.
+
+    :type exemplar: Exemplar
+    :param exemplar: Optional exemplar for this bucket, omit if the
+    distribution does not have a histogram.
+    """
+
+    def __init__(self, count, exemplar=None):
+        self._count = count
+        self._exemplar = exemplar
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.count,
+                ))
+
+    @property
+    def count(self):
+        return self._count
+
+    @property
+    def exemplar(self):
+        return self._exemplar
+
+
+class Explicit(object):
+    """Set of explicit bucket boundaries.
+
+    Specifies a set of buckets with arbitrary upper-bounds.  This defines
+    size(bounds) + 1 (= N) buckets. The boundaries for bucket index i are:
+
+        - [0, bounds[i]) for i == 0
+        - [bounds[i-1], bounds[i]) for 0 < i < N-1
+        - [bounds[i-1], +infinity) for i == N-1
+    """
+
+    def __init__(self, bounds):
+        if not bounds:
+            raise ValueError("Bounds must not be null or empty")
+        if bounds != sorted(set(bounds)):
+            raise ValueError("Bounds must be strictly increasing")
+        if bounds[0] <= 0:
+            raise ValueError("Bounds must be positive")
+        self._bounds = bounds
+
+    @property
+    def bounds(self):
+        return copy(self._bounds)
+
+
+class BucketOptions(object):
+    """Container for bucket options, including explicit boundaries.
+
+    A Distribution may optionally contain a histogram of the values in the
+    population. The bucket boundaries for that histogram are described by
+    BucketOptions.
+
+    If bucket_options has no type, then there is no histogram associated with
+    the Distribution.
+    """
+
+    def __init__(self, type_=None):
+        self._type = type_
+
+    def __repr__(self):
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.type_,
+                ))
+
+    @property
+    def type_(self):
+        return self._type
+
+
+class ValueDistribution(object):
+    """Summary statistics for a population of values.
+
+    Distribution contains summary statistics for a population of values. It
+    optionally contains a histogram representing the distribution of those
+    values across a set of buckets.
+
+    :type count: int
+    :param count: The number of values in the population.
+
+    :type sum_: float
+    :param sum_: The sum of the values in the population.
+
+    :type sum_of_squared_deviation: float
+    :param sum_of_squared_deviation: The sum of squared deviations from the
+    mean of the values in the population.
+
+    :type bucket_options: :class: 'BucketOptions'
+    :param bucket_options: Bucket boundaries for the histogram of the values in
+    the population.
+
+    :type buckets: list(:class: 'Bucket')
+    :param buckets: Histogram buckets for the given bucket boundaries.
+    """
+
+    def __init__(self,
+                 count,
+                 sum_,
+                 sum_of_squared_deviation,
+                 bucket_options,
+                 buckets=None):
+        if count < 0:
+            raise ValueError("count must be non-negative")
+        elif count == 0:
+            if sum_ != 0:
+                raise ValueError("sum_ must be 0 if count is 0")
+            if sum_of_squared_deviation != 0:
+                raise ValueError("sum_of_squared_deviation must be 0 if count "
+                                 "is 0")
+        if bucket_options is None:
+            raise ValueError("bucket_options must not be null")
+        if bucket_options.type_ is None:
+            if buckets is not None:
+                raise ValueError("buckets must be null if the distribution "
+                                 "has no histogram (i.e. bucket_options.type "
+                                 "is null)")
+        else:
+            if len(buckets) != len(bucket_options.type_.bounds) + 1:
+                # Note that this includes the implicit 0 and positive-infinity
+                # boundaries, so bounds [1, 2] implies three buckets: [[0, 1),
+                # [1, 2), [2, inf)].
+                raise ValueError("There must be one bucket for each pair of "
+                                 "boundaries")
+            if count != sum(bucket.count for bucket in buckets):
+                raise ValueError("The distribution count must equal the sum "
+                                 "of bucket counts")
+        self._count = count
+        self._sum = sum_
+        self._sum_of_squared_deviation = sum_of_squared_deviation
+        self._bucket_options = bucket_options
+        self._buckets = buckets
+
+    def __repr__(self):
+        try:
+            bounds = self.bucket_options.type_.bounds,
+        except AttributeError:
+            bounds = None
+
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    bounds
+                ))
+
+    @property
+    def count(self):
+        return self._count
+
+    @property
+    def sum(self):
+        return self._sum
+
+    @property
+    def sum_of_squared_deviation(self):
+        return self._sum_of_squared_deviation
+
+    @property
+    def bucket_options(self):
+        return self._bucket_options
+
+    @property
+    def buckets(self):
+        return self._buckets

.venv/lib/python3.11/site-packages/opencensus/metrics/label_key.py

@@ -0,0 +1,51 @@
+# Copyright 2018, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+class LabelKey(object):
+    """The label keys associated with the metric descriptor.
+
+    :type key: str
+    :param key: the key for the label
+
+    :type description: str
+    :param description: description of the label
+    """
+    def __init__(self, key, description):
+        self._key = key
+        self._description = description
+
+    def __repr__(self):
+        if self.description:
+            return ('{}({}, description="{}")'
+                    .format(
+                        type(self).__name__,
+                        self.key,
+                        self.description
+                    ))
+        return ("{}({})"
+                .format(
+                    type(self).__name__,
+                    self.key,
+                ))
+
+    @property
+    def key(self):
+        """the key for the label"""
+        return self._key
+
+    @property
+    def description(self):
+        """a human-readable description of what this label key represents"""
+        return self._description

.venv/lib/python3.11/site-packages/opencensus/metrics/transport.py

@@ -0,0 +1,145 @@
+# Copyright 2019, OpenCensus Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import itertools
+import logging
+
+from opencensus.common import utils
+from opencensus.common.schedule import PeriodicTask
+from opencensus.trace import execution_context
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_INTERVAL = 60
+GRACE_PERIOD = 5
+
+
+class TransportError(Exception):
+    pass
+
+
+class PeriodicMetricTask(PeriodicTask):
+    """Thread that periodically calls a given function.
+
+    :type interval: int or float
+    :param interval: Seconds between calls to the function.
+
+    :type function: function
+    :param function: The function to call.
+
+    :type args: list
+    :param args: The args passed in while calling `function`.
+
+    :type kwargs: dict
+    :param args: The kwargs passed in while calling `function`.
+
+    :type name: str
+    :param name: The source of the worker. Used for naming.
+    """
+
+    daemon = True
+
+    def __init__(
+        self,
+        interval=None,
+        function=None,
+        args=None,
+        kwargs=None,
+        name=None
+    ):
+        if interval is None:
+            interval = DEFAULT_INTERVAL
+
+        self.func = function
+        self.args = args
+        self.kwargs = kwargs
+
+        def func(*aa, **kw):
+            try:
+                return self.func(*aa, **kw)
+            except TransportError as ex:
+                logger.exception(ex)
+                self.cancel()
+            except Exception as ex:
+                logger.exception("Error handling metric export: {}".format(ex))
+
+        super(PeriodicMetricTask, self).__init__(
+            interval, func, args, kwargs, '{} Worker'.format(name)
+        )
+
+    def run(self):
+        # Indicate that this thread is an exporter thread.
+        # Used to suppress tracking of requests in this thread
+        execution_context.set_is_exporter(True)
+        super(PeriodicMetricTask, self).run()
+
+    def close(self):
+        try:
+            # Suppress request tracking on flush
+            execution_context.set_is_exporter(True)
+            self.func(*self.args, **self.kwargs)
+            execution_context.set_is_exporter(False)
+        except Exception as ex:
+            logger.exception("Error handling metric flush: {}".format(ex))
+        self.cancel()
+
+
+def get_exporter_thread(metric_producers, exporter, interval=None):
+    """Get a running task that periodically exports metrics.
+
+    Get a `PeriodicTask` that periodically calls:
+
+        export(itertools.chain(*all_gets))
+
+    where all_gets is the concatenation of all metrics produced by the metric
+    producers in metric_producers, each calling metric_producer.get_metrics()
+
+    :type metric_producers:
+    list(:class:`opencensus.metrics.export.metric_producer.MetricProducer`)
+    :param metric_producers: The list of metric producers to use to get metrics
+
+    :type exporter: :class:`opencensus.stats.base_exporter.MetricsExporter`
+    :param exporter: The exporter to use to export metrics.
+
+    :type interval: int or float
+    :param interval: Seconds between export calls.
+
+    :rtype: :class:`PeriodicTask`
+    :return: A running thread responsible calling the exporter.
+
+    """
+    weak_gets = [utils.get_weakref(producer.get_metrics)
+                 for producer in metric_producers]
+    weak_export = utils.get_weakref(exporter.export_metrics)
+
+    def export_all():
+        all_gets = []
+        for weak_get in weak_gets:
+            get = weak_get()
+            if get is None:
+                raise TransportError("Metric producer is not available")
+            all_gets.append(get())
+        export = weak_export()
+        if export is None:
+            raise TransportError("Metric exporter is not available")
+
+        export(itertools.chain(*all_gets))
+
+    tt = PeriodicMetricTask(
+        interval,
+        export_all,
+        name=exporter.__class__.__name__
+    )
+    tt.start()
+    return tt

.venv/lib/python3.11/site-packages/proto/__init__.py

@@ -0,0 +1,72 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .enums import Enum
+from .fields import Field
+from .fields import MapField
+from .fields import RepeatedField
+from .marshal import Marshal
+from .message import Message
+from .modules import define_module as module
+from .primitives import ProtoType
+from .version import __version__
+
+
+DOUBLE = ProtoType.DOUBLE
+FLOAT = ProtoType.FLOAT
+INT64 = ProtoType.INT64
+UINT64 = ProtoType.UINT64
+INT32 = ProtoType.INT32
+FIXED64 = ProtoType.FIXED64
+FIXED32 = ProtoType.FIXED32
+BOOL = ProtoType.BOOL
+STRING = ProtoType.STRING
+MESSAGE = ProtoType.MESSAGE
+BYTES = ProtoType.BYTES
+UINT32 = ProtoType.UINT32
+ENUM = ProtoType.ENUM
+SFIXED32 = ProtoType.SFIXED32
+SFIXED64 = ProtoType.SFIXED64
+SINT32 = ProtoType.SINT32
+SINT64 = ProtoType.SINT64
+
+
+__all__ = (
+    "__version__",
+    "Enum",
+    "Field",
+    "MapField",
+    "RepeatedField",
+    "Marshal",
+    "Message",
+    "module",
+    # Expose the types directly.
+    "DOUBLE",
+    "FLOAT",
+    "INT64",
+    "UINT64",
+    "INT32",
+    "FIXED64",
+    "FIXED32",
+    "BOOL",
+    "STRING",
+    "MESSAGE",
+    "BYTES",
+    "UINT32",
+    "ENUM",
+    "SFIXED32",
+    "SFIXED64",
+    "SINT32",
+    "SINT64",
+)

.venv/lib/python3.11/site-packages/proto/enums.py

@@ -0,0 +1,163 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import enum
+
+from google.protobuf import descriptor_pb2
+
+from proto import _file_info
+from proto import _package_info
+from proto.marshal.rules.enums import EnumRule
+
+
+class ProtoEnumMeta(enum.EnumMeta):
+    """A metaclass for building and registering protobuf enums."""
+
+    def __new__(mcls, name, bases, attrs):
+        # Do not do any special behavior for `proto.Enum` itself.
+        if bases[0] == enum.IntEnum:
+            return super().__new__(mcls, name, bases, attrs)
+
+        # Get the essential information about the proto package, and where
+        # this component belongs within the file.
+        package, marshal = _package_info.compile(name, attrs)
+
+        # Determine the local path of this proto component within the file.
+        local_path = tuple(attrs.get("__qualname__", name).split("."))
+
+        # Sanity check: We get the wrong full name if a class is declared
+        # inside a function local scope; correct this.
+        if "<locals>" in local_path:
+            ix = local_path.index("<locals>")
+            local_path = local_path[: ix - 1] + local_path[ix + 1 :]
+
+        # Determine the full name in protocol buffers.
+        full_name = ".".join((package,) + local_path).lstrip(".")
+        filename = _file_info._FileInfo.proto_file_name(
+            attrs.get("__module__", name.lower())
+        )
+
+        # Retrieve any enum options.
+        # We expect something that looks like an EnumOptions message,
+        # either an actual instance or a dict-like representation.
+        pb_options = "_pb_options"
+        opts = attrs.pop(pb_options, {})
+        # This is the only portable way to remove the _pb_options name
+        # from the enum attrs.
+        # In 3.7 onwards, we can define an _ignore_ attribute and do some
+        # mucking around with that.
+        if pb_options in attrs._member_names:
+            if isinstance(attrs._member_names, list):
+                idx = attrs._member_names.index(pb_options)
+                attrs._member_names.pop(idx)
+            else:  # Python 3.11.0b3
+                del attrs._member_names[pb_options]
+
+        # Make the descriptor.
+        enum_desc = descriptor_pb2.EnumDescriptorProto(
+            name=name,
+            # Note: the superclass ctor removes the variants, so get them now.
+            # Note: proto3 requires that the first variant value be zero.
+            value=sorted(
+                (
+                    descriptor_pb2.EnumValueDescriptorProto(name=name, number=number)
+                    # Minor hack to get all the enum variants out.
+                    # Use the `_member_names` property to get only the enum members
+                    # See https://github.com/googleapis/proto-plus-python/issues/490
+                    for name, number in attrs.items()
+                    if name in attrs._member_names and isinstance(number, int)
+                ),
+                key=lambda v: v.number,
+            ),
+            options=opts,
+        )
+
+        file_info = _file_info._FileInfo.maybe_add_descriptor(filename, package)
+        if len(local_path) == 1:
+            file_info.descriptor.enum_type.add().MergeFrom(enum_desc)
+        else:
+            file_info.nested_enum[local_path] = enum_desc
+
+        # Run the superclass constructor.
+        cls = super().__new__(mcls, name, bases, attrs)
+
+        # We can't just add a "_meta" element to attrs because the Enum
+        # machinery doesn't know what to do with a non-int value.
+        # The pb is set later, in generate_file_pb
+        cls._meta = _EnumInfo(full_name=full_name, pb=None)
+
+        file_info.enums[full_name] = cls
+
+        # Register the enum with the marshal.
+        marshal.register(cls, EnumRule(cls))
+
+        # Generate the descriptor for the file if it is ready.
+        if file_info.ready(new_class=cls):
+            file_info.generate_file_pb(new_class=cls, fallback_salt=full_name)
+
+        # Done; return the class.
+        return cls
+
+
+class Enum(enum.IntEnum, metaclass=ProtoEnumMeta):
+    """A enum object that also builds a protobuf enum descriptor."""
+
+    def _comparable(self, other):
+        # Avoid 'isinstance' to prevent other IntEnums from matching
+        return type(other) in (type(self), int)
+
+    def __hash__(self):
+        return hash(self.value)
+
+    def __eq__(self, other):
+        if not self._comparable(other):
+            return NotImplemented
+
+        return self.value == int(other)
+
+    def __ne__(self, other):
+        if not self._comparable(other):
+            return NotImplemented
+
+        return self.value != int(other)
+
+    def __lt__(self, other):
+        if not self._comparable(other):
+            return NotImplemented
+
+        return self.value < int(other)
+
+    def __le__(self, other):
+        if not self._comparable(other):
+            return NotImplemented
+
+        return self.value <= int(other)
+
+    def __ge__(self, other):
+        if not self._comparable(other):
+            return NotImplemented
+
+        return self.value >= int(other)
+
+    def __gt__(self, other):
+        if not self._comparable(other):
+            return NotImplemented
+
+        return self.value > int(other)
+
+
+class _EnumInfo:
+    def __init__(self, *, full_name: str, pb):
+        self.full_name = full_name
+        self.pb = pb

.venv/lib/python3.11/site-packages/proto/marshal/__init__.py

@@ -0,0 +1,18 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .marshal import Marshal
+
+
+__all__ = ("Marshal",)

.venv/lib/python3.11/site-packages/proto/marshal/collections/__init__.py

@@ -0,0 +1,24 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from .maps import MapComposite
+from .repeated import Repeated
+from .repeated import RepeatedComposite
+
+
+__all__ = (
+    "MapComposite",
+    "Repeated",
+    "RepeatedComposite",
+)

.venv/lib/python3.11/site-packages/proto/marshal/collections/maps.py

@@ -0,0 +1,82 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import collections
+
+from proto.utils import cached_property
+from google.protobuf.message import Message
+
+
+class MapComposite(collections.abc.MutableMapping):
+    """A view around a mutable sequence in protocol buffers.
+
+    This implements the full Python MutableMapping interface, but all methods
+    modify the underlying field container directly.
+    """
+
+    @cached_property
+    def _pb_type(self):
+        """Return the protocol buffer type for this sequence."""
+        # Huzzah, another hack. Still less bad than RepeatedComposite.
+        return type(self.pb.GetEntryClass()().value)
+
+    def __init__(self, sequence, *, marshal):
+        """Initialize a wrapper around a protobuf map.
+
+        Args:
+            sequence: A protocol buffers map.
+            marshal (~.MarshalRegistry): An instantiated marshal, used to
+                convert values going to and from this map.
+        """
+        self._pb = sequence
+        self._marshal = marshal
+
+    def __contains__(self, key):
+        # Protocol buffers is so permissive that querying for the existence
+        # of a key will in of itself create it.
+        #
+        # By taking a tuple of the keys and querying that, we avoid sending
+        # the lookup to protocol buffers and therefore avoid creating the key.
+        return key in tuple(self.keys())
+
+    def __getitem__(self, key):
+        # We handle raising KeyError ourselves, because otherwise protocol
+        # buffers will create the key if it does not exist.
+        if key not in self:
+            raise KeyError(key)
+        return self._marshal.to_python(self._pb_type, self.pb[key])
+
+    def __setitem__(self, key, value):
+        pb_value = self._marshal.to_proto(self._pb_type, value, strict=True)
+        # Directly setting a key is not allowed; however, protocol buffers
+        # is so permissive that querying for the existence of a key will in
+        # of itself create it.
+        #
+        # Therefore, we create a key that way (clearing any fields that may
+        # be set) and then merge in our values.
+        self.pb[key].Clear()
+        self.pb[key].MergeFrom(pb_value)
+
+    def __delitem__(self, key):
+        self.pb.pop(key)
+
+    def __len__(self):
+        return len(self.pb)
+
+    def __iter__(self):
+        return iter(self.pb)
+
+    @property
+    def pb(self):
+        return self._pb

.venv/lib/python3.11/site-packages/proto/marshal/collections/repeated.py

@@ -0,0 +1,189 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import collections
+import copy
+from typing import Iterable
+
+from proto.utils import cached_property
+
+
+class Repeated(collections.abc.MutableSequence):
+    """A view around a mutable sequence in protocol buffers.
+
+    This implements the full Python MutableSequence interface, but all methods
+    modify the underlying field container directly.
+    """
+
+    def __init__(self, sequence, *, marshal, proto_type=None):
+        """Initialize a wrapper around a protobuf repeated field.
+
+        Args:
+            sequence: A protocol buffers repeated field.
+            marshal (~.MarshalRegistry): An instantiated marshal, used to
+                convert values going to and from this map.
+        """
+        self._pb = sequence
+        self._marshal = marshal
+        self._proto_type = proto_type
+
+    def __copy__(self):
+        """Copy this object and return the copy."""
+        return type(self)(self.pb[:], marshal=self._marshal)
+
+    def __delitem__(self, key):
+        """Delete the given item."""
+        del self.pb[key]
+
+    def __eq__(self, other):
+        if hasattr(other, "pb"):
+            return tuple(self.pb) == tuple(other.pb)
+        return tuple(self.pb) == tuple(other) if isinstance(other, Iterable) else False
+
+    def __getitem__(self, key):
+        """Return the given item."""
+        return self.pb[key]
+
+    def __len__(self):
+        """Return the length of the sequence."""
+        return len(self.pb)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __repr__(self):
+        return repr([*self])
+
+    def __setitem__(self, key, value):
+        self.pb[key] = value
+
+    def insert(self, index: int, value):
+        """Insert ``value`` in the sequence before ``index``."""
+        self.pb.insert(index, value)
+
+    def sort(self, *, key: str = None, reverse: bool = False):
+        """Stable sort *IN PLACE*."""
+        self.pb.sort(key=key, reverse=reverse)
+
+    @property
+    def pb(self):
+        return self._pb
+
+
+class RepeatedComposite(Repeated):
+    """A view around a mutable sequence of messages in protocol buffers.
+
+    This implements the full Python MutableSequence interface, but all methods
+    modify the underlying field container directly.
+    """
+
+    @cached_property
+    def _pb_type(self):
+        """Return the protocol buffer type for this sequence."""
+        # Provide the marshal-given proto_type, if any.
+        # Used for RepeatedComposite of Enum.
+        if self._proto_type is not None:
+            return self._proto_type
+
+        # There is no public-interface mechanism to determine the type
+        # of what should go in the list (and the C implementation seems to
+        # have no exposed mechanism at all).
+        #
+        # If the list has members, use the existing list members to
+        # determine the type.
+        if len(self.pb) > 0:
+            return type(self.pb[0])
+
+        # We have no members in the list, so we get the type from the attributes.
+        if hasattr(self.pb, "_message_descriptor") and hasattr(
+            self.pb._message_descriptor, "_concrete_class"
+        ):
+            return self.pb._message_descriptor._concrete_class
+
+        # Fallback logic in case attributes are not available
+        # In order to get the type, we create a throw-away copy and add a
+        # blank member to it.
+        canary = copy.deepcopy(self.pb).add()
+        return type(canary)
+
+    def __eq__(self, other):
+        if super().__eq__(other):
+            return True
+        return (
+            tuple([i for i in self]) == tuple(other)
+            if isinstance(other, Iterable)
+            else False
+        )
+
+    def __getitem__(self, key):
+        return self._marshal.to_python(self._pb_type, self.pb[key])
+
+    def __setitem__(self, key, value):
+        # The underlying protocol buffer does not define __setitem__, so we
+        # have to implement all the operations on our own.
+
+        # If ``key`` is an integer, as in list[index] = value:
+        if isinstance(key, int):
+            if -len(self) <= key < len(self):
+                self.pop(key)  # Delete the old item.
+                self.insert(key, value)  # Insert the new item in its place.
+            else:
+                raise IndexError("list assignment index out of range")
+
+        # If ``key`` is a slice object, as in list[start:stop:step] = [values]:
+        elif isinstance(key, slice):
+            start, stop, step = key.indices(len(self))
+
+            if not isinstance(value, collections.abc.Iterable):
+                raise TypeError("can only assign an iterable")
+
+            if step == 1:  # Is not an extended slice.
+                # Assign all the new values to the sliced part, replacing the
+                # old values, if any, and unconditionally inserting those
+                # values whose indices already exceed the slice length.
+                for index, item in enumerate(value):
+                    if start + index < stop:
+                        self.pop(start + index)
+                    self.insert(start + index, item)
+
+                # If there are less values than the length of the slice, remove
+                # the remaining elements so that the slice adapts to the
+                # newly provided values.
+                for _ in range(stop - start - len(value)):
+                    self.pop(start + len(value))
+
+            else:  # Is an extended slice.
+                indices = range(start, stop, step)
+
+                if len(value) != len(indices):  # XXX: Use PEP 572 on 3.8+
+                    raise ValueError(
+                        f"attempt to assign sequence of size "
+                        f"{len(value)} to extended slice of size "
+                        f"{len(indices)}"
+                    )
+
+                # Assign each value to its index, calling this function again
+                # with individual integer indexes that get processed above.
+                for index, item in zip(indices, value):
+                    self[index] = item
+
+        else:
+            raise TypeError(
+                f"list indices must be integers or slices, not {type(key).__name__}"
+            )
+
+    def insert(self, index: int, value):
+        """Insert ``value`` in the sequence before ``index``."""
+        pb_value = self._marshal.to_proto(self._pb_type, value)
+        self.pb.insert(index, pb_value)

.venv/lib/python3.11/site-packages/proto/marshal/compat.py

@@ -0,0 +1,64 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# This file pulls in the container types from internal protocol buffers,
+# and exports the types available.
+#
+# If the C extensions were not installed, then their container types will
+# not be included.
+
+from google.protobuf.internal import containers
+
+# Import all message types to ensure that pyext types are recognized
+# when upb types exist. Conda's protobuf defaults to pyext despite upb existing.
+# See https://github.com/googleapis/proto-plus-python/issues/470
+try:
+    from google._upb import _message as _message_upb
+except ImportError:
+    _message_upb = None
+
+try:
+    from google.protobuf.pyext import _message as _message_pyext
+except ImportError:
+    _message_pyext = None
+
+
+repeated_composite_types = (containers.RepeatedCompositeFieldContainer,)
+repeated_scalar_types = (containers.RepeatedScalarFieldContainer,)
+map_composite_types = (containers.MessageMap,)
+
+# In `proto/marshal.py`, for compatibility with protobuf 5.x,
+# we'll use `map_composite_type_names` to check whether
+# the name of the class of a protobuf type is
+# `MessageMapContainer`, and, if `True`, return a MapComposite.
+# See https://github.com/protocolbuffers/protobuf/issues/16596
+map_composite_type_names = ("MessageMapContainer",)
+
+for message in [_message_upb, _message_pyext]:
+    if message:
+        repeated_composite_types += (message.RepeatedCompositeContainer,)
+        repeated_scalar_types += (message.RepeatedScalarContainer,)
+
+        try:
+            map_composite_types += (message.MessageMapContainer,)
+        except AttributeError:
+            # The `MessageMapContainer` attribute is not available in Protobuf 5.x+
+            pass
+
+__all__ = (
+    "repeated_composite_types",
+    "repeated_scalar_types",
+    "map_composite_types",
+    "map_composite_type_names",
+)

.venv/lib/python3.11/site-packages/proto/marshal/marshal.py

@@ -0,0 +1,297 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import abc
+import enum
+
+from google.protobuf import message
+from google.protobuf import duration_pb2
+from google.protobuf import timestamp_pb2
+from google.protobuf import field_mask_pb2
+from google.protobuf import struct_pb2
+from google.protobuf import wrappers_pb2
+
+from proto.marshal import compat
+from proto.marshal.collections import MapComposite
+from proto.marshal.collections import Repeated
+from proto.marshal.collections import RepeatedComposite
+
+from proto.marshal.rules import bytes as pb_bytes
+from proto.marshal.rules import stringy_numbers
+from proto.marshal.rules import dates
+from proto.marshal.rules import struct
+from proto.marshal.rules import wrappers
+from proto.marshal.rules import field_mask
+from proto.primitives import ProtoType
+
+
+class Rule(abc.ABC):
+    """Abstract class definition for marshal rules."""
+
+    @classmethod
+    def __subclasshook__(cls, C):
+        if hasattr(C, "to_python") and hasattr(C, "to_proto"):
+            return True
+        return NotImplemented
+
+
+class BaseMarshal:
+    """The base class to translate between protobuf and Python classes.
+
+    Protocol buffers defines many common types (e.g. Timestamp, Duration)
+    which also exist in the Python standard library. The marshal essentially
+    translates between these: it keeps a registry of common protocol buffers
+    and their Python representations, and translates back and forth.
+
+    The protocol buffer class is always the "key" in this relationship; when
+    presenting a message, the declared field types are used to determine
+    whether a value should be transformed into another class. Similarly,
+    when accepting a Python value (when setting a field, for example),
+    the declared field type is still used. This means that, if appropriate,
+    multiple protocol buffer types may use the same Python type.
+
+    The primary implementation of this is :class:`Marshal`, which should
+    usually be used instead of this class directly.
+    """
+
+    def __init__(self):
+        self._rules = {}
+        self._noop = NoopRule()
+        self.reset()
+
+    def register(self, proto_type: type, rule: Rule = None):
+        """Register a rule against the given ``proto_type``.
+
+        This function expects a ``proto_type`` (the descriptor class) and
+        a ``rule``; an object with a ``to_python`` and ``to_proto`` method.
+        Each method should return the appropriate Python or protocol buffer
+        type, and be idempotent (e.g. accept either type as input).
+
+        This function can also be used as a decorator::
+
+            @marshal.register(timestamp_pb2.Timestamp)
+            class TimestampRule:
+                ...
+
+        In this case, the class will be initialized for you with zero
+        arguments.
+
+        Args:
+            proto_type (type): A protocol buffer message type.
+            rule: A marshal object
+        """
+        # If a rule was provided, register it and be done.
+        if rule:
+            # Ensure the rule implements Rule.
+            if not isinstance(rule, Rule):
+                raise TypeError(
+                    "Marshal rule instances must implement "
+                    "`to_proto` and `to_python` methods."
+                )
+
+            # Register the rule.
+            self._rules[proto_type] = rule
+            return
+
+        # Create an inner function that will register an instance of the
+        # marshal class to this object's registry, and return it.
+        def register_rule_class(rule_class: type):
+            # Ensure the rule class is a valid rule.
+            if not issubclass(rule_class, Rule):
+                raise TypeError(
+                    "Marshal rule subclasses must implement "
+                    "`to_proto` and `to_python` methods."
+                )
+
+            # Register the rule class.
+            self._rules[proto_type] = rule_class()
+            return rule_class
+
+        return register_rule_class
+
+    def reset(self):
+        """Reset the registry to its initial state."""
+        self._rules.clear()
+
+        # Register date and time wrappers.
+        self.register(timestamp_pb2.Timestamp, dates.TimestampRule())
+        self.register(duration_pb2.Duration, dates.DurationRule())
+
+        # Register FieldMask wrappers.
+        self.register(field_mask_pb2.FieldMask, field_mask.FieldMaskRule())
+
+        # Register nullable primitive wrappers.
+        self.register(wrappers_pb2.BoolValue, wrappers.BoolValueRule())
+        self.register(wrappers_pb2.BytesValue, wrappers.BytesValueRule())
+        self.register(wrappers_pb2.DoubleValue, wrappers.DoubleValueRule())
+        self.register(wrappers_pb2.FloatValue, wrappers.FloatValueRule())
+        self.register(wrappers_pb2.Int32Value, wrappers.Int32ValueRule())
+        self.register(wrappers_pb2.Int64Value, wrappers.Int64ValueRule())
+        self.register(wrappers_pb2.StringValue, wrappers.StringValueRule())
+        self.register(wrappers_pb2.UInt32Value, wrappers.UInt32ValueRule())
+        self.register(wrappers_pb2.UInt64Value, wrappers.UInt64ValueRule())
+
+        # Register the google.protobuf.Struct wrappers.
+        #
+        # These are aware of the marshal that created them, because they
+        # create RepeatedComposite and MapComposite instances directly and
+        # need to pass the marshal to them.
+        self.register(struct_pb2.Value, struct.ValueRule(marshal=self))
+        self.register(struct_pb2.ListValue, struct.ListValueRule(marshal=self))
+        self.register(struct_pb2.Struct, struct.StructRule(marshal=self))
+
+        # Special case for bytes to allow base64 encode/decode
+        self.register(ProtoType.BYTES, pb_bytes.BytesRule())
+
+        # Special case for int64 from strings because of dict round trip.
+        # See https://github.com/protocolbuffers/protobuf/issues/2679
+        for rule_class in stringy_numbers.STRINGY_NUMBER_RULES:
+            self.register(rule_class._proto_type, rule_class())
+
+    def get_rule(self, proto_type):
+        # Rules are needed to convert values between proto-plus and pb.
+        # Retrieve the rule for the specified proto type.
+        # The NoopRule will be used when a rule is not found.
+        rule = self._rules.get(proto_type, self._noop)
+
+        # If we don't find a rule, also check under `_instances`
+        # in case there is a rule in another package.
+        # See https://github.com/googleapis/proto-plus-python/issues/349
+        if rule == self._noop and hasattr(self, "_instances"):
+            for _, instance in self._instances.items():
+                rule = instance._rules.get(proto_type, self._noop)
+                if rule != self._noop:
+                    break
+        return rule
+
+    def to_python(self, proto_type, value, *, absent: bool = None):
+        # Internal protobuf has its own special type for lists of values.
+        # Return a view around it that implements MutableSequence.
+        value_type = type(value)  # Minor performance boost over isinstance
+        if value_type in compat.repeated_composite_types:
+            return RepeatedComposite(value, marshal=self)
+        if value_type in compat.repeated_scalar_types:
+            if isinstance(proto_type, type):
+                return RepeatedComposite(value, marshal=self, proto_type=proto_type)
+            else:
+                return Repeated(value, marshal=self)
+
+        # Same thing for maps of messages.
+        # See https://github.com/protocolbuffers/protobuf/issues/16596
+        # We need to look up the name of the type in compat.map_composite_type_names
+        # as class `MessageMapContainer` is no longer exposed
+        # This is done to avoid taking a breaking change in proto-plus.
+        if (
+            value_type in compat.map_composite_types
+            or value_type.__name__ in compat.map_composite_type_names
+        ):
+            return MapComposite(value, marshal=self)
+        return self.get_rule(proto_type=proto_type).to_python(value, absent=absent)
+
+    def to_proto(self, proto_type, value, *, strict: bool = False):
+        # The protos in google/protobuf/struct.proto are exceptional cases,
+        # because they can and should represent themselves as lists and dicts.
+        # These cases are handled in their rule classes.
+        if proto_type not in (
+            struct_pb2.Value,
+            struct_pb2.ListValue,
+            struct_pb2.Struct,
+        ):
+            # For our repeated and map view objects, simply return the
+            # underlying pb.
+            if isinstance(value, (Repeated, MapComposite)):
+                return value.pb
+
+            # Convert lists and tuples recursively.
+            if isinstance(value, (list, tuple)):
+                return type(value)(self.to_proto(proto_type, i) for i in value)
+
+        # Convert dictionaries recursively when the proto type is a map.
+        # This is slightly more complicated than converting a list or tuple
+        # because we have to step through the magic that protocol buffers does.
+        #
+        # Essentially, a type of map<string, Foo> will show up here as
+        # a FoosEntry with a `key` field, `value` field, and a `map_entry`
+        # annotation. We need to do the conversion based on the `value`
+        # field's type.
+        if isinstance(value, dict) and (
+            proto_type.DESCRIPTOR.has_options
+            and proto_type.DESCRIPTOR.GetOptions().map_entry
+        ):
+            recursive_type = type(proto_type().value)
+            return {k: self.to_proto(recursive_type, v) for k, v in value.items()}
+
+        pb_value = self.get_rule(proto_type=proto_type).to_proto(value)
+
+        # Sanity check: If we are in strict mode, did we get the value we want?
+        if strict and not isinstance(pb_value, proto_type):
+            raise TypeError(
+                "Parameter must be instance of the same class; "
+                "expected {expected}, got {got}".format(
+                    expected=proto_type.__name__,
+                    got=pb_value.__class__.__name__,
+                ),
+            )
+        # Return the final value.
+        return pb_value
+
+
+class Marshal(BaseMarshal):
+    """The translator between protocol buffer and Python instances.
+
+    The bulk of the implementation is in :class:`BaseMarshal`. This class
+    adds identity tracking: multiple instantiations of :class:`Marshal` with
+    the same name will provide the same instance.
+    """
+
+    _instances = {}
+
+    def __new__(cls, *, name: str):
+        """Create a marshal instance.
+
+        Args:
+            name (str): The name of the marshal. Instantiating multiple
+                marshals with the same ``name`` argument will provide the
+                same marshal each time.
+        """
+        klass = cls._instances.get(name)
+        if klass is None:
+            klass = cls._instances[name] = super().__new__(cls)
+
+        return klass
+
+    def __init__(self, *, name: str):
+        """Instantiate a marshal.
+
+        Args:
+            name (str): The name of the marshal. Instantiating multiple
+                marshals with the same ``name`` argument will provide the
+                same marshal each time.
+        """
+        self._name = name
+        if not hasattr(self, "_rules"):
+            super().__init__()
+
+
+class NoopRule:
+    """A catch-all rule that does nothing."""
+
+    def to_python(self, pb_value, *, absent: bool = None):
+        return pb_value
+
+    def to_proto(self, value):
+        return value
+
+
+__all__ = ("Marshal",)

.venv/lib/python3.11/site-packages/proto/marshal/rules/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2018 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.