diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/common/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ccb65767ac1ea637378d5031ff7e6d51b6abff9d
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/common/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/backports/__init__.py b/.venv/lib/python3.11/site-packages/opencensus/common/backports/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..23c08786d0c885e158bffe7d881d5cd5a9f0bc68
--- /dev/null
+++ b/.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__
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/backports/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/common/backports/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..be2ca7d05a8f30bbb240c10ba82f17c43d742ffa
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/common/backports/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/configuration/__init__.py b/.venv/lib/python3.11/site-packages/opencensus/common/configuration/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..cbd8cf288d5271f59a2a451a82f3c0110a47b581
--- /dev/null
+++ b/.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)
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/configuration/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/common/configuration/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..613cea2178ef8733f16da92b800976f17322bd19
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/common/configuration/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/__init__.py b/.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/gcp_metadata_config.py b/.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/gcp_metadata_config.py
new file mode 100644
index 0000000000000000000000000000000000000000..0cdfde6744998c4f9a118d03047ab22c8f994273
--- /dev/null
+++ b/.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 : https://cloud.google.com/compute/docs/storing
+ -retrieving-metadata
+ """
+ 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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/k8s_utils.py b/.venv/lib/python3.11/site-packages/opencensus/common/monitored_resource/k8s_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..82265f505125cc76fbd5a6cf5eb325b05c5bebcb
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/version/__init__.py b/.venv/lib/python3.11/site-packages/opencensus/common/version/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..2927eec884d46d0a26b3fa97b613a787710b1c20
--- /dev/null
+++ b/.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'
diff --git a/.venv/lib/python3.11/site-packages/opencensus/common/version/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/common/version/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..70296e49039ce93f0b05f127a1ba10f4a17457a8
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/common/version/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/__init__.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__init__.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..44601c82f640b82e1f2f896319093185ccad7ef7
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/cumulative.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/cumulative.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c6c8c408b8d2be13561d3e1385faa20bd7a31bc0
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/cumulative.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/gauge.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/gauge.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..42627763c065e7f1fd73a67bb553bcf318356186
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/gauge.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/metric.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/metric.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c889c03de26b0b21d92feedb9ec9f33c78df99ad
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/metric.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/point.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/point.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..45230e03519d530c1d9033445d74b0e72a1d0cb9
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/point.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/summary.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/summary.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9f62746232dc8983f31be3c852d5fff8ad2d042e
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/summary.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/time_series.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/time_series.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..03c32e68b9c0d3d7bc11ffe69276476dfe95d225
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/__pycache__/time_series.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/cumulative.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/cumulative.py
new file mode 100644
index 0000000000000000000000000000000000000000..10eea4472bd5a9903af1fc53c8b0fdccdf3d595e
--- /dev/null
+++ b/.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."""
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/gauge.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/gauge.py
new file mode 100644
index 0000000000000000000000000000000000000000..149f38328431ad9f3cdaf4469811913a95373891
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric.py
new file mode 100644
index 0000000000000000000000000000000000000000..658a27e45125376833965c07c6c3db599f5498f8
--- /dev/null
+++ b/.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")
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric_descriptor.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric_descriptor.py
new file mode 100644
index 0000000000000000000000000000000000000000..955a5ff879d9ce401b98e55a725751ec81f3bba7
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric_producer.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/metric_producer.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5f53e18d8ead2a35ec43e8175088906d3c8f76e
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/point.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/point.py
new file mode 100644
index 0000000000000000000000000000000000000000..0168f211337d33ed43385d77f4d3ab01a9308643
--- /dev/null
+++ b/.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
+ ))
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/summary.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/summary.py
new file mode 100644
index 0000000000000000000000000000000000000000..d7fddcbf20b53107ba93431cb5205ee7817430e4
--- /dev/null
+++ b/.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')
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/time_series.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/time_series.py
new file mode 100644
index 0000000000000000000000000000000000000000..637f8a17ffd264963920fff8e965453f9e7ab5c7
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/export/value.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/export/value.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3aa66c81c48c235aae199ca73eb291b1364822f
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/label_key.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/label_key.py
new file mode 100644
index 0000000000000000000000000000000000000000..f6cfa156878af82ad1fff804a347bb3e7f1609fd
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/metrics/transport.py b/.venv/lib/python3.11/site-packages/opencensus/metrics/transport.py
new file mode 100644
index 0000000000000000000000000000000000000000..33253db8e20e00820bab42cd4754cdfaf117f098
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/opencensus/trace/tracers/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/opencensus/trace/tracers/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..54dc6056679d9620e41bf1b581ca9a9f002355b9
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/opencensus/trace/tracers/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/__init__.py b/.venv/lib/python3.11/site-packages/proto/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8780991c0426bcd08c7bbb134411539c9a7ff7ea
--- /dev/null
+++ b/.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",
+)
diff --git a/.venv/lib/python3.11/site-packages/proto/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..22c5991fab7797f65318f925e5d399f0b5b03c45
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/__pycache__/datetime_helpers.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/__pycache__/datetime_helpers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d08b58276a105c016feaa5d2e9fcf0f0d26d9c79
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/__pycache__/datetime_helpers.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/__pycache__/enums.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/__pycache__/enums.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..34a2d4d59551e11052a1381e346c7c11b08ac69c
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/__pycache__/enums.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/__pycache__/fields.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/__pycache__/fields.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..aee1001153efab376fd6c18dc9f716fa15ad194a
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/__pycache__/fields.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/enums.py b/.venv/lib/python3.11/site-packages/proto/enums.py
new file mode 100644
index 0000000000000000000000000000000000000000..4073c2a3c677dfa67d76462df1b5e8eea59c751f
--- /dev/null
+++ b/.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 "" in local_path:
+ ix = local_path.index("")
+ 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
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/__init__.py b/.venv/lib/python3.11/site-packages/proto/marshal/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..621ea3695f931708b24e8d9dad4c6907d8947b15
--- /dev/null
+++ b/.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",)
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/collections/__init__.py b/.venv/lib/python3.11/site-packages/proto/marshal/collections/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b80a546c26a5cab35ea7eb02a781f3fd70f6d31
--- /dev/null
+++ b/.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",
+)
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/collections/__pycache__/maps.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/collections/__pycache__/maps.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f60ac127a6b7099a121abdc7388eeb2044244b64
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/collections/__pycache__/maps.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/collections/__pycache__/repeated.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/collections/__pycache__/repeated.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dad0765d62c14e5495355cae1ecb66ea009db88f
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/collections/__pycache__/repeated.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/collections/maps.py b/.venv/lib/python3.11/site-packages/proto/marshal/collections/maps.py
new file mode 100644
index 0000000000000000000000000000000000000000..3c4857161458291b3dc98c5a37d1f0bf4dae4dab
--- /dev/null
+++ b/.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
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/collections/repeated.py b/.venv/lib/python3.11/site-packages/proto/marshal/collections/repeated.py
new file mode 100644
index 0000000000000000000000000000000000000000..a6560411cd71ac15a68f617ce7fe1c6e1e9cbabb
--- /dev/null
+++ b/.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)
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/compat.py b/.venv/lib/python3.11/site-packages/proto/marshal/compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..b393acf5a447cc79913be8d3420e0bdc64c77382
--- /dev/null
+++ b/.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",
+)
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/marshal.py b/.venv/lib/python3.11/site-packages/proto/marshal/marshal.py
new file mode 100644
index 0000000000000000000000000000000000000000..d278421a57975c7fd12e26e37cb5b83f1f7e222b
--- /dev/null
+++ b/.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 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",)
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__init__.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b0c7da3d7725b221298f8a38dadf11d4802dce0d
--- /dev/null
+++ b/.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.
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/__init__.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/__init__.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..869300b5a3574366f44cc56d6e1d0e37a316d23b
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/__init__.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/bytes.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/bytes.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ac79acbc8fece7941f3755ae85c1696d58436a8a
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/bytes.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/dates.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/dates.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a1d614cac8efc6ee41e6a81809363bc5aea3221b
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/dates.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/enums.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/enums.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b07921bf7c66305caf9645ef577cd7c398c9fd1b
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/enums.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/field_mask.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/field_mask.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4e7195199930e0d4b6f862bd449153053369418
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/field_mask.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/message.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/message.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..77fa4fde2ab73470ea5e1b4f0a135b2b7e70f763
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/message.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/stringy_numbers.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/stringy_numbers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..350930ea084590aeb2f9af618583a73c89cbd626
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/stringy_numbers.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/struct.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/struct.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc7a1ebfa3cb868723d8c0d99112307d91d8dcb2
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/struct.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/wrappers.cpython-311.pyc b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/wrappers.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4390c729e2562343573658fd7d399b999868313a
Binary files /dev/null and b/.venv/lib/python3.11/site-packages/proto/marshal/rules/__pycache__/wrappers.cpython-311.pyc differ
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/bytes.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/bytes.py
new file mode 100644
index 0000000000000000000000000000000000000000..080b0a03d4a028705ebd67978310e32c99ec740c
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/bytes.py
@@ -0,0 +1,44 @@
+# Copyright (C) 2021 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
+#
+# 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 base64
+
+
+class BytesRule:
+ """A marshal between Python strings and protobuf bytes.
+
+ Note: this conversion is asymmetric because Python does have a bytes type.
+ It is sometimes necessary to convert proto bytes fields to strings, e.g. for
+ JSON encoding, marshalling a message to a dict. Because bytes fields can
+ represent arbitrary data, bytes fields are base64 encoded when they need to
+ be represented as strings.
+
+ It is necessary to have the conversion be bidirectional, i.e.
+ my_message == MyMessage(MyMessage.to_dict(my_message))
+
+ To accomplish this, we need to intercept assignments from strings and
+ base64 decode them back into bytes.
+ """
+
+ def to_python(self, value, *, absent: bool = None):
+ return value
+
+ def to_proto(self, value):
+ if isinstance(value, str):
+ value = value.encode("utf-8")
+ value += b"=" * (4 - len(value) % 4) # padding
+ value = base64.urlsafe_b64decode(value)
+
+ return value
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/dates.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/dates.py
new file mode 100644
index 0000000000000000000000000000000000000000..33d12829b3cc562ab463347a6ea76b5d28b55dd4
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/dates.py
@@ -0,0 +1,85 @@
+# 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 datetime import datetime
+from datetime import timedelta
+from datetime import timezone
+
+from google.protobuf import duration_pb2
+from google.protobuf import timestamp_pb2
+from proto import datetime_helpers, utils
+
+
+class TimestampRule:
+ """A marshal between Python datetimes and protobuf timestamps.
+
+ Note: Python datetimes are less precise than protobuf datetimes
+ (microsecond vs. nanosecond level precision). If nanosecond-level
+ precision matters, it is recommended to interact with the internal
+ proto directly.
+ """
+
+ def to_python(
+ self, value, *, absent: bool = None
+ ) -> datetime_helpers.DatetimeWithNanoseconds:
+ if isinstance(value, timestamp_pb2.Timestamp):
+ if absent:
+ return None
+ return datetime_helpers.DatetimeWithNanoseconds.from_timestamp_pb(value)
+ return value
+
+ def to_proto(self, value) -> timestamp_pb2.Timestamp:
+ if isinstance(value, datetime_helpers.DatetimeWithNanoseconds):
+ return value.timestamp_pb()
+ if isinstance(value, datetime):
+ return timestamp_pb2.Timestamp(
+ seconds=int(value.timestamp()),
+ nanos=value.microsecond * 1000,
+ )
+ if isinstance(value, str):
+ timestamp_value = timestamp_pb2.Timestamp()
+ timestamp_value.FromJsonString(value=value)
+ return timestamp_value
+ return value
+
+
+class DurationRule:
+ """A marshal between Python timedeltas and protobuf durations.
+
+ Note: Python timedeltas are less precise than protobuf durations
+ (microsecond vs. nanosecond level precision). If nanosecond-level
+ precision matters, it is recommended to interact with the internal
+ proto directly.
+ """
+
+ def to_python(self, value, *, absent: bool = None) -> timedelta:
+ if isinstance(value, duration_pb2.Duration):
+ return timedelta(
+ days=value.seconds // 86400,
+ seconds=value.seconds % 86400,
+ microseconds=value.nanos // 1000,
+ )
+ return value
+
+ def to_proto(self, value) -> duration_pb2.Duration:
+ if isinstance(value, timedelta):
+ return duration_pb2.Duration(
+ seconds=value.days * 86400 + value.seconds,
+ nanos=value.microseconds * 1000,
+ )
+ if isinstance(value, str):
+ duration_value = duration_pb2.Duration()
+ duration_value.FromJsonString(value=value)
+ return duration_value
+ return value
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/enums.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/enums.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cfc312764b6ab8ff38ebc12dd256d6b1434d6c2
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/enums.py
@@ -0,0 +1,59 @@
+# 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.
+
+from typing import Type
+import enum
+import warnings
+
+
+class EnumRule:
+ """A marshal for converting between integer values and enum values."""
+
+ def __init__(self, enum_class: Type[enum.IntEnum]):
+ self._enum = enum_class
+
+ def to_python(self, value, *, absent: bool = None):
+ if isinstance(value, int) and not isinstance(value, self._enum):
+ try:
+ # Coerce the int on the wire to the enum value.
+ return self._enum(value)
+ except ValueError:
+ # Since it is possible to add values to enums, we do
+ # not want to flatly error on this.
+ #
+ # However, it is useful to make some noise about it so
+ # the user realizes that an unexpected value came along.
+ warnings.warn(
+ "Unrecognized {name} enum value: {value}".format(
+ name=self._enum.__name__,
+ value=value,
+ )
+ )
+ return value
+
+ def to_proto(self, value):
+ # Accept enum values and coerce to the pure integer.
+ # This is not strictly necessary (protocol buffers can take these
+ # objects as they subclass int) but nevertheless seems like the
+ # right thing to do.
+ if isinstance(value, self._enum):
+ return value.value
+
+ # If a string is provided that matches an enum value, coerce it
+ # to the enum value.
+ if isinstance(value, str):
+ return self._enum[value].value
+
+ # We got a pure integer; pass it on.
+ return value
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/field_mask.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/field_mask.py
new file mode 100644
index 0000000000000000000000000000000000000000..348e7e3995d4e5fe810f87567a1296eb0b6510dd
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/field_mask.py
@@ -0,0 +1,36 @@
+# Copyright 2022 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 google.protobuf import field_mask_pb2
+
+
+class FieldMaskRule:
+ """A marshal between FieldMask and strings.
+
+ See https://github.com/googleapis/proto-plus-python/issues/333
+ and
+ https://developers.google.com/protocol-buffers/docs/proto3#json
+ for more details.
+ """
+
+ def to_python(self, value, *, absent: bool = None):
+ return value
+
+ def to_proto(self, value):
+ if isinstance(value, str):
+ field_mask_value = field_mask_pb2.FieldMask()
+ field_mask_value.FromJsonString(value=value)
+ return field_mask_value
+
+ return value
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/message.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/message.py
new file mode 100644
index 0000000000000000000000000000000000000000..479a2d95277631e7a659e5a1bfebd211fb1c22d7
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/message.py
@@ -0,0 +1,52 @@
+# 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.
+
+
+class MessageRule:
+ """A marshal for converting between a descriptor and proto.Message."""
+
+ def __init__(self, descriptor: type, wrapper: type):
+ self._descriptor = descriptor
+ self._wrapper = wrapper
+
+ def to_python(self, value, *, absent: bool = None):
+ if isinstance(value, self._descriptor):
+ return self._wrapper.wrap(value)
+ return value
+
+ def to_proto(self, value):
+ if isinstance(value, self._wrapper):
+ return self._wrapper.pb(value)
+ if isinstance(value, dict) and not self.is_map:
+ # We need to use the wrapper's marshaling to handle
+ # potentially problematic nested messages.
+ try:
+ # Try the fast path first.
+ return self._descriptor(**value)
+ except (TypeError, ValueError) as ex:
+ # If we have a TypeError or Valueerror,
+ # try the slow path in case the error
+ # was:
+ # - an int64/string issue.
+ # - a missing key issue in case a key only exists with a `_` suffix.
+ # See related issue: https://github.com/googleapis/python-api-core/issues/227.
+ # - a missing key issue due to nested struct. See: b/321905145.
+ return self._wrapper(value)._pb
+ return value
+
+ @property
+ def is_map(self):
+ """Return True if the descriptor is a map entry, False otherwise."""
+ desc = self._descriptor.DESCRIPTOR
+ return desc.has_options and desc.GetOptions().map_entry
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/stringy_numbers.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/stringy_numbers.py
new file mode 100644
index 0000000000000000000000000000000000000000..dae69e9c9121d9b71b2c98a2f2028ca2c9c7d66d
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/stringy_numbers.py
@@ -0,0 +1,71 @@
+# Copyright (C) 2021 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
+#
+# 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 proto.primitives import ProtoType
+
+
+class StringyNumberRule:
+ """A marshal between certain numeric types and strings
+
+ This is a necessary hack to allow round trip conversion
+ from messages to dicts back to messages.
+
+ See https://github.com/protocolbuffers/protobuf/issues/2679
+ and
+ https://developers.google.com/protocol-buffers/docs/proto3#json
+ for more details.
+ """
+
+ def to_python(self, value, *, absent: bool = None):
+ return value
+
+ def to_proto(self, value):
+ if value is not None:
+ return self._python_type(value)
+
+ return None
+
+
+class Int64Rule(StringyNumberRule):
+ _python_type = int
+ _proto_type = ProtoType.INT64
+
+
+class UInt64Rule(StringyNumberRule):
+ _python_type = int
+ _proto_type = ProtoType.UINT64
+
+
+class SInt64Rule(StringyNumberRule):
+ _python_type = int
+ _proto_type = ProtoType.SINT64
+
+
+class Fixed64Rule(StringyNumberRule):
+ _python_type = int
+ _proto_type = ProtoType.FIXED64
+
+
+class SFixed64Rule(StringyNumberRule):
+ _python_type = int
+ _proto_type = ProtoType.SFIXED64
+
+
+STRINGY_NUMBER_RULES = [
+ Int64Rule,
+ UInt64Rule,
+ SInt64Rule,
+ Fixed64Rule,
+ SFixed64Rule,
+]
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/struct.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/struct.py
new file mode 100644
index 0000000000000000000000000000000000000000..0e34587b26b19c06caa63bf469e26c3ef6bb9dda
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/struct.py
@@ -0,0 +1,143 @@
+# 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.abc
+
+from google.protobuf import struct_pb2
+
+from proto.marshal.collections import maps
+from proto.marshal.collections import repeated
+
+
+class ValueRule:
+ """A rule to marshal between google.protobuf.Value and Python values."""
+
+ def __init__(self, *, marshal):
+ self._marshal = marshal
+
+ def to_python(self, value, *, absent: bool = None):
+ """Coerce the given value to the appropriate Python type.
+
+ Note that both NullValue and absent fields return None.
+ In order to disambiguate between these two options,
+ use containment check,
+ E.g.
+ "value" in foo
+ which is True for NullValue and False for an absent value.
+ """
+ kind = value.WhichOneof("kind")
+ if kind == "null_value" or absent:
+ return None
+ if kind == "bool_value":
+ return bool(value.bool_value)
+ if kind == "number_value":
+ return float(value.number_value)
+ if kind == "string_value":
+ return str(value.string_value)
+ if kind == "struct_value":
+ return self._marshal.to_python(
+ struct_pb2.Struct,
+ value.struct_value,
+ absent=False,
+ )
+ if kind == "list_value":
+ return self._marshal.to_python(
+ struct_pb2.ListValue,
+ value.list_value,
+ absent=False,
+ )
+ # If more variants are ever added, we want to fail loudly
+ # instead of tacitly returning None.
+ raise ValueError("Unexpected kind: %s" % kind) # pragma: NO COVER
+
+ def to_proto(self, value) -> struct_pb2.Value:
+ """Return a protobuf Value object representing this value."""
+ if isinstance(value, struct_pb2.Value):
+ return value
+ if value is None:
+ return struct_pb2.Value(null_value=0)
+ if isinstance(value, bool):
+ return struct_pb2.Value(bool_value=value)
+ if isinstance(value, (int, float)):
+ return struct_pb2.Value(number_value=float(value))
+ if isinstance(value, str):
+ return struct_pb2.Value(string_value=value)
+ if isinstance(value, collections.abc.Sequence):
+ return struct_pb2.Value(
+ list_value=self._marshal.to_proto(struct_pb2.ListValue, value),
+ )
+ if isinstance(value, collections.abc.Mapping):
+ return struct_pb2.Value(
+ struct_value=self._marshal.to_proto(struct_pb2.Struct, value),
+ )
+ raise ValueError("Unable to coerce value: %r" % value)
+
+
+class ListValueRule:
+ """A rule translating google.protobuf.ListValue and list-like objects."""
+
+ def __init__(self, *, marshal):
+ self._marshal = marshal
+
+ def to_python(self, value, *, absent: bool = None):
+ """Coerce the given value to a Python sequence."""
+ return (
+ None
+ if absent
+ else repeated.RepeatedComposite(value.values, marshal=self._marshal)
+ )
+
+ def to_proto(self, value) -> struct_pb2.ListValue:
+ # We got a proto, or else something we sent originally.
+ # Preserve the instance we have.
+ if isinstance(value, struct_pb2.ListValue):
+ return value
+ if isinstance(value, repeated.RepeatedComposite):
+ return struct_pb2.ListValue(values=[v for v in value.pb])
+
+ # We got a list (or something list-like); convert it.
+ return struct_pb2.ListValue(
+ values=[self._marshal.to_proto(struct_pb2.Value, v) for v in value]
+ )
+
+
+class StructRule:
+ """A rule translating google.protobuf.Struct and dict-like objects."""
+
+ def __init__(self, *, marshal):
+ self._marshal = marshal
+
+ def to_python(self, value, *, absent: bool = None):
+ """Coerce the given value to a Python mapping."""
+ return (
+ None if absent else maps.MapComposite(value.fields, marshal=self._marshal)
+ )
+
+ def to_proto(self, value) -> struct_pb2.Struct:
+ # We got a proto, or else something we sent originally.
+ # Preserve the instance we have.
+ if isinstance(value, struct_pb2.Struct):
+ return value
+ if isinstance(value, maps.MapComposite):
+ return struct_pb2.Struct(
+ fields={k: v for k, v in value.pb.items()},
+ )
+
+ # We got a dict (or something dict-like); convert it.
+ answer = struct_pb2.Struct(
+ fields={
+ k: self._marshal.to_proto(struct_pb2.Value, v) for k, v in value.items()
+ }
+ )
+ return answer
diff --git a/.venv/lib/python3.11/site-packages/proto/marshal/rules/wrappers.py b/.venv/lib/python3.11/site-packages/proto/marshal/rules/wrappers.py
new file mode 100644
index 0000000000000000000000000000000000000000..5bc89e595851e42e70c32cb6d970084c48959d57
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/marshal/rules/wrappers.py
@@ -0,0 +1,84 @@
+# 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 google.protobuf import wrappers_pb2
+
+
+class WrapperRule:
+ """A marshal for converting the protobuf wrapper classes to Python.
+
+ This class converts between ``google.protobuf.BoolValue``,
+ ``google.protobuf.StringValue``, and their siblings to the appropriate
+ Python equivalents.
+
+ These are effectively similar to the protobuf primitives except
+ that None becomes a possible value.
+ """
+
+ def to_python(self, value, *, absent: bool = None):
+ if isinstance(value, self._proto_type):
+ if absent:
+ return None
+ return value.value
+ return value
+
+ def to_proto(self, value):
+ if isinstance(value, self._python_type):
+ return self._proto_type(value=value)
+ return value
+
+
+class DoubleValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.DoubleValue
+ _python_type = float
+
+
+class FloatValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.FloatValue
+ _python_type = float
+
+
+class Int64ValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.Int64Value
+ _python_type = int
+
+
+class UInt64ValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.UInt64Value
+ _python_type = int
+
+
+class Int32ValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.Int32Value
+ _python_type = int
+
+
+class UInt32ValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.UInt32Value
+ _python_type = int
+
+
+class BoolValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.BoolValue
+ _python_type = bool
+
+
+class StringValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.StringValue
+ _python_type = str
+
+
+class BytesValueRule(WrapperRule):
+ _proto_type = wrappers_pb2.BytesValue
+ _python_type = bytes
diff --git a/.venv/lib/python3.11/site-packages/proto/primitives.py b/.venv/lib/python3.11/site-packages/proto/primitives.py
new file mode 100644
index 0000000000000000000000000000000000000000..cff2094c678bb52e75bf48271ae5c8e1d603310c
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/primitives.py
@@ -0,0 +1,38 @@
+# 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 enum
+
+
+class ProtoType(enum.IntEnum):
+ """The set of basic types in protocol buffers."""
+
+ # These values come from google/protobuf/descriptor.proto
+ DOUBLE = 1
+ FLOAT = 2
+ INT64 = 3
+ UINT64 = 4
+ INT32 = 5
+ FIXED64 = 6
+ FIXED32 = 7
+ BOOL = 8
+ STRING = 9
+ MESSAGE = 11
+ BYTES = 12
+ UINT32 = 13
+ ENUM = 14
+ SFIXED32 = 15
+ SFIXED64 = 16
+ SINT32 = 17
+ SINT64 = 18
diff --git a/.venv/lib/python3.11/site-packages/proto/utils.py b/.venv/lib/python3.11/site-packages/proto/utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac3c471a2e8b5e2792175f4aa25220efba422264
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/proto/utils.py
@@ -0,0 +1,58 @@
+# 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 functools
+
+
+def has_upb():
+ try:
+ from google._upb import _message # pylint: disable=unused-import
+
+ has_upb = True
+ except ImportError:
+ has_upb = False
+ return has_upb
+
+
+def cached_property(fx):
+ """Make the callable into a cached property.
+
+ Similar to @property, but the function will only be called once per
+ object.
+
+ Args:
+ fx (Callable[]): The property function.
+
+ Returns:
+ Callable[]: The wrapped function.
+ """
+
+ @functools.wraps(fx)
+ def inner(self):
+ # Sanity check: If there is no cache at all, create an empty cache.
+ if not hasattr(self, "_cached_values"):
+ object.__setattr__(self, "_cached_values", {})
+
+ # If and only if the function's result is not in the cache,
+ # run the function.
+ if fx.__name__ not in self._cached_values:
+ self._cached_values[fx.__name__] = fx(self)
+
+ # Return the value from cache.
+ return self._cached_values[fx.__name__]
+
+ return property(inner)
+
+
+__all__ = ("cached_property",)
diff --git a/.venv/lib/python3.11/site-packages/pybind11/include/pybind11/detail/class.h b/.venv/lib/python3.11/site-packages/pybind11/include/pybind11/detail/class.h
new file mode 100644
index 0000000000000000000000000000000000000000..b990507d629b4260d66d51e23a7f34a0fa465c9e
--- /dev/null
+++ b/.venv/lib/python3.11/site-packages/pybind11/include/pybind11/detail/class.h
@@ -0,0 +1,767 @@
+/*
+ pybind11/detail/class.h: Python C API implementation details for py::class_
+
+ Copyright (c) 2017 Wenzel Jakob
+
+ All rights reserved. Use of this source code is governed by a
+ BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include
+#include
+
+#include "exception_translation.h"
+
+PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+PYBIND11_NAMESPACE_BEGIN(detail)
+
+#if !defined(PYPY_VERSION)
+# define PYBIND11_BUILTIN_QUALNAME
+# define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj)
+#else
+// In PyPy, we still set __qualname__ so that we can produce reliable function type
+// signatures; in CPython this macro expands to nothing:
+# define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj) \
+ setattr((PyObject *) obj, "__qualname__", nameobj)
+#endif
+
+inline std::string get_fully_qualified_tp_name(PyTypeObject *type) {
+#if !defined(PYPY_VERSION)
+ return type->tp_name;
+#else
+ auto module_name = handle((PyObject *) type).attr("__module__").cast();
+ if (module_name == PYBIND11_BUILTINS_MODULE)
+ return type->tp_name;
+ else
+ return std::move(module_name) + "." + type->tp_name;
+#endif
+}
+
+inline PyTypeObject *type_incref(PyTypeObject *type) {
+ Py_INCREF(type);
+ return type;
+}
+
+#if !defined(PYPY_VERSION)
+
+/// `pybind11_static_property.__get__()`: Always pass the class instead of the instance.
+extern "C" inline PyObject *pybind11_static_get(PyObject *self, PyObject * /*ob*/, PyObject *cls) {
+ return PyProperty_Type.tp_descr_get(self, cls, cls);
+}
+
+/// `pybind11_static_property.__set__()`: Just like the above `__get__()`.
+extern "C" inline int pybind11_static_set(PyObject *self, PyObject *obj, PyObject *value) {
+ PyObject *cls = PyType_Check(obj) ? obj : (PyObject *) Py_TYPE(obj);
+ return PyProperty_Type.tp_descr_set(self, cls, value);
+}
+
+// Forward declaration to use in `make_static_property_type()`
+inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type);
+
+/** A `static_property` is the same as a `property` but the `__get__()` and `__set__()`
+ methods are modified to always use the object type instead of a concrete instance.
+ Return value: New reference. */
+inline PyTypeObject *make_static_property_type() {
+ constexpr auto *name = "pybind11_static_property";
+ auto name_obj = reinterpret_steal