Add files using upload-large-folder tool

.venv/lib/python3.11/site-packages/depyf-0.18.0.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv/lib/python3.11/site-packages/depyf-0.18.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Tsinghua University, Machine Learning Group (THUML)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

.venv/lib/python3.11/site-packages/depyf-0.18.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.1
+Name: depyf
+Version: 0.18.0
+Summary: Decompile python functions, from bytecode to source code!
+Home-page: https://github.com/thuml/depyf
+Author: Kaichao You
+Author-email: youkaichao@gmail.com
+License: MIT
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astor
+Requires-Dist: dill
+Provides-Extra: dev
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: flake8 ; extra == 'dev'
+Requires-Dist: autopep8 ; extra == 'dev'
+
+![Logo](imgs/logo-and-text.svg)
+
+[![Documentation Status](https://readthedocs.org/projects/depyf/badge/?version=latest)](https://depyf.readthedocs.io/en/latest/) ![Supported Python Versions](https://img.shields.io/badge/python-%203.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11-blue) ![Python Decompilation Tests](https://github.com/thuml/depyf/actions/workflows/test_decompile.yml/badge.svg) ![PyTorch Integration Tests](https://github.com/thuml/depyf/actions/workflows/test_pytorch.yml/badge.svg) [![Test Coverage](https://codecov.io/github/thuml/depyf/graph/badge.svg?token=DUQ1CQ0I5U)](https://codecov.io/github/thuml/depyf) ![MIT License](https://img.shields.io/github/license/thuml/depyf)
+
+> `depyf` is proud to be a [PyTorch ecosystem project](https://pytorch.org/ecosystem/). Check out the announcement blog [https://pytorch.org/blog/introducing-depyf/](https://pytorch.org/blog/introducing-depyf/) for more details.
+
+Have you ever felt overwhelmed by the complexities of `torch.compile`? Diving into its workings can feel like black magic, with bytecode and Python internal details that many users fail to understand, hindering them from understanding and adapting to `torch.compile`.
+
+If you also face the problem, then you might be interested in `depyf`. As the logo suggests, `depyf` is a software tool to leverage advanced Python features (the Python snake symbol) to open up internal details (the internal gears symbol) of PyTorch's compiler `torch.compile` (the PyTorch logo), so that users can understand it, adapt to it, and tune their code (the debugger symbol) to get maximum performance benefit out of it.
+
+:warning: This project is developed under close collaborations with the PyTorch team. Therefore, it requires very new features from PyTorch to support better understanding of `torch.compile`. **Please use this project along with PyTorch>=2.2.0 (PyTorch nightly is recommended)**. Visit the [PyTorch website](https://pytorch.org/) for how to install different versions of PyTorch.
+
+:warning: During development, we seek suggestions from the community quite a lot. You may find some early usage examples from some discussion forums or social media platforms. **Please follow the latest documentation for how to use this tool.**
+
+# Why `depyf`?
+
+If you want to understand bytecode generated by `torch.compile`, then `depyf` might be the only choice for you. Below we tested several existing decompilers, they struggle to decompile simple Python bytecode across versions, and have poor support for PyTorch.
+
+| Decompiler  | Python 3.8   | Python 3.9 | Python 3.10 | Python 3.11 | PyTorch |
+|-------------|--------------|------------|-------------|-------------|---------|
+| [decompyle3](https://github.com/rocky/python-decompile3)  | 90.6% (77/85)  | ×          | ×           | ×           | ×       |
+| [uncompyle6](https://github.com/rocky/python-uncompyle6)  | 91.8% (78/85)| ×          | ×           | ×           | ×       |
+| [pycdc](https://github.com/zrax/pycdc)       | 74.1% (63/85)  | 74.1% (63/85)| 74.1% (63/85) | 67.1% (57/85)          | 19.3% (27/140)|
+| [depyf](https://github.com/thuml/depyf)       | 100% (85/85) | 100% (85/85)| 100% (85/85)| 100% (85/85)| 100% (140/140)|
+
+# Installation
+
+Stable release: `pip install depyf`
+
+Nightly version (recommended): `pip install git+https://github.com/thuml/depyf.git`
+
+# Usage
+
+The main usage is quite simple: just wrap your code within a context manager:
+
+```python
+import torch
+from torch import _dynamo as torchdynamo
+from typing import List
+
+@torch.compile
+def toy_example(a, b):
+    x = a / (torch.abs(a) + 1)
+    if b.sum() < 0:
+        b = b * -1
+    return x * b
+
+def main():
+    for _ in range(100):
+        toy_example(torch.randn(10), torch.randn(10))
+
+if __name__ == "__main__":
+    # main()
+    # surround the code you want to run inside `with depyf.prepare_debug`
+    import depyf
+    with depyf.prepare_debug("./dump_src_dir"):
+        main()
+```
+
+Then you can see all the details of `torch.compile` inside the directory `./dump_src_dir`. The details are organized into the following:
+
+- `full_code_for_xxx.py` for each function using `torch.compile`
+- `__transformed_code_for_xxx.py` for Python code associated with each graph.
+- `__transformed_code_for_xxx.py.xxx_bytecode` for Python bytecode, dumped code object, can be loaded via `dill.load(open("/path/to/file", "wb"))`. Note that the `load` function might import some modules like `transformers`. Make sure you have these modules installed.
+- `__compiled_fn_xxx.py` for each computation graph and its optimization:
+  - `Captured Graph`: a plain forward computation graph
+  - `Joint Graph`: joint forward-backward graph from `AOTAutograd`
+  - `Forward Graph`: forward graph from `AOTAutograd`
+  - `Backward Graph`: backward graph from `AOTAutograd`
+  - `kernel xxx`: compiled CPU/GPU kernel wrapper from Inductor.
+
+We collect [all the compilation artifacts](https://github.com/thuml/learn_torch.compile) when testing over 100 deep learning models. You can take a look to learn how the PyTorch compiler works.
+
+If you want to use debugger to step through the above code, just add another context manager (and launch the script through debuggers):
+
+```python
+import torch
+from torch import _dynamo as torchdynamo
+from typing import List
+
+@torch.compile
+def toy_example(a, b):
+    x = a / (torch.abs(a) + 1)
+    if b.sum() < 0:
+        b = b * -1
+    return x * b
+
+def main():
+    for _ in range(100):
+        toy_example(torch.randn(10), torch.randn(10))
+
+if __name__ == "__main__":
+    import depyf
+    with depyf.prepare_debug("./dump_src_dir"):
+        main()
+    # surround the code you want to debug inside `with depyf.debug()`
+    with depyf.debug():
+        main()
+```
+
+Calling `depyf.debug()` will pause the program for you to set breakpoints, and then you can use debuggers to hit breakpoints in these files under the `./dump_src_dir` directory you specified above.
+
+# Contact
+
+If you have any question about `depyf`, feel free to open issues to reach out! Any discussion/issue report/PR is welcome. Or contact youkaichao@gmail.com if you have any other questions.
+
+# Citing `depyf`
+
+If you find `depyf` useful, please cite it in your publications.
+
+```latex
+@article{you2024depyf,
+      title={depyf: Open the Opaque Box of PyTorch Compiler for Machine Learning Researchers}, 
+      author={Kaichao You and Runsheng Bai and Meng Cao and Jianmin Wang and Ion Stoica and Mingsheng Long},
+      year={2024},
+      eprint={2403.13839},
+      journal={arXiv},
+      primaryClass={cs.LG},
+      url={https://github.com/thuml/depyf}
+}
+```

.venv/lib/python3.11/site-packages/depyf-0.18.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+depyf-0.18.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+depyf-0.18.0.dist-info/LICENSE,sha256=lzua0q7KCQHlSWzC19FuMW0BAF6WZZ3CV7R9A_3scmY,1108
+depyf-0.18.0.dist-info/METADATA,sha256=BeQoG-ccxNdRfp6WoHhRCC9h2C71nsGLMKlPoGM1qw0,7102
+depyf-0.18.0.dist-info/RECORD,,
+depyf-0.18.0.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+depyf-0.18.0.dist-info/top_level.txt,sha256=Q8OIJwiCISz0EGVEbMqj3ybR3yHWYbLNxR0ocsccRoo,6
+depyf/VERSION.txt,sha256=QsG7ukni09uOW2RMD0kLOlCvEaKkRnPYnJ03IRLMrX8,6
+depyf/__init__.py,sha256=LbOU08fulsuNrWJrbh-RP3aotFRDBOhPbPRJcriNiNk,841
+depyf/__pycache__/__init__.cpython-311.pyc,,
+depyf/__pycache__/code_transform.cpython-311.pyc,,
+depyf/__pycache__/decompiler.cpython-311.pyc,,
+depyf/__pycache__/optimization.cpython-311.pyc,,
+depyf/__pycache__/utils.cpython-311.pyc,,
+depyf/code_transform.py,sha256=yLFkRxyXCfE_B4FOik4a89IAJJg5cFrl9TB7m15hDXs,17855
+depyf/decompiler.py,sha256=SP9nbIhpMqygnHTCYnoe538ZPSygP9dFV3jtl7fYPUw,53998
+depyf/explain/__init__.py,sha256=pXasvun6VLMr5YqXkaEenMZqrLLtL5jkEi-H86LI15k,620
+depyf/explain/__pycache__/__init__.cpython-311.pyc,,
+depyf/explain/__pycache__/enable_debugging.cpython-311.pyc,,
+depyf/explain/__pycache__/enhance_logging.cpython-311.pyc,,
+depyf/explain/__pycache__/global_variables.cpython-311.pyc,,
+depyf/explain/__pycache__/patched___call__.cpython-311.pyc,,
+depyf/explain/__pycache__/patched__exec_with_source.cpython-311.pyc,,
+depyf/explain/__pycache__/patched_boxed_run.cpython-311.pyc,,
+depyf/explain/__pycache__/patched_lazy_format_graph_code.cpython-311.pyc,,
+depyf/explain/__pycache__/patched_load_by_key_path.cpython-311.pyc,,
+depyf/explain/__pycache__/utils.cpython-311.pyc,,
+depyf/explain/enable_debugging.py,sha256=cOTGwTJlYFAwVW_kgFvBhFITCO7lj9eOhh5zXnvF-0M,12602
+depyf/explain/enhance_logging.py,sha256=x-9Y3rxlIW30-cYIUfqv_Ha3h_0AwFnZ7_7tisDso2k,2745
+depyf/explain/global_variables.py,sha256=cdE2qMzfK4LvP-VJXP36ZQMG1m896mN7hJsQmbPWRkQ,451
+depyf/explain/patched___call__.py,sha256=kEg09Pt08gDeICr5D_SryS2TJ2k5lDqbv_m5VViD43Q,352
+depyf/explain/patched__exec_with_source.py,sha256=yEAB3k9KOrQ75275fY0ghdjs3qMXESYKV0VH6C947wk,750
+depyf/explain/patched_boxed_run.py,sha256=Uq70zcEcY-F3cupORR10_OdRU9TOzfOVqRW4Dpw8w30,83
+depyf/explain/patched_lazy_format_graph_code.py,sha256=3YOke3DCeISdS_-X-ucalkDeXAsWRsu4PwE5oJ4at9g,3200
+depyf/explain/patched_load_by_key_path.py,sha256=1NmSDdET0qqm0NsHg1a4q-H5T0JljEXPqVSrYInmIuY,774
+depyf/explain/utils.py,sha256=i2MarlLUnqQAOCc0SXHUrHI5eW0LliF1vD8Wk0LfLlY,13682
+depyf/optimization.py,sha256=0sPpOC76tzmUlHrNpI2gUZ4_qEcsUVWdkNxEu3DeeCg,2969
+depyf/utils.py,sha256=-0AjE-vrFV-Gkgg62S83L0TO45nlbNlyuaxrLDksfrQ,3239

.venv/lib/python3.11/site-packages/depyf-0.18.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.41.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

.venv/lib/python3.11/site-packages/depyf-0.18.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+depyf

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

@@ -0,0 +1 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)

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

@@ -0,0 +1,43 @@
+# 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.
+
+try:
+    # For Python 3.0 and later
+    from urllib.request import urlopen, Request
+    from urllib.error import HTTPError, URLError
+except ImportError:
+    # Fall back to Python 2's urllib2
+    from urllib2 import urlopen, Request
+    from urllib2 import HTTPError, URLError
+
+
+import socket
+
+_REQUEST_TIMEOUT = 2  # in secs
+
+
+def get_request(request_url, request_headers=dict()):
+    """Execute http get request on given request_url with optional headers
+    """
+    request = Request(request_url)
+    for key, val in request_headers.items():
+        request.add_header(key, val)
+
+    try:
+        response = urlopen(request, timeout=_REQUEST_TIMEOUT)
+        response_content = response.read()
+    except (HTTPError, URLError, socket.timeout):
+        response_content = None
+
+    return response_content

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

@@ -0,0 +1,95 @@
+# 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 json
+
+from opencensus.common.http_handler import get_request
+
+REGION_KEY = 'region'
+ACCOUNT_ID_KEY = 'aws_account'
+INSTANCE_ID_KEY = 'instance_id'
+
+# AWS provides Instance Metadata via below url
+_AWS_INSTANCE_IDENTITY_DOCUMENT_URI = \
+    "http://169.254.169.254/latest/dynamic/instance-identity/document"
+
+_AWS_ATTRIBUTES = {
+    # Region is the AWS region for the VM. The format of this field is
+    # "aws:{region}", where supported values for {region} are listed at
+    # http://docs.aws.amazon.com/general/latest/gr/rande.html.
+    'region': REGION_KEY,
+
+    # accountId is the AWS account number for the VM.
+    'accountId': ACCOUNT_ID_KEY,
+
+    # instanceId is the instance id of the instance.
+    'instanceId': INSTANCE_ID_KEY
+}
+
+# inited is used to make sure AWS initialize executes only once.
+inited = False
+
+# Detects if the application is running on EC2 by making a connection to AWS
+# instance identity document URI.If connection is successful, application
+# should be on an EC2 instance.
+is_running_on_aws = False
+
+aws_metadata_map = {}
+
+
+class AwsIdentityDocumentUtils(object):
+    """Util methods for getting and parsing AWS instance identity document."""
+
+    inited = False
+    is_running = False
+
+    @classmethod
+    def _initialize_aws_identity_document(cls):
+        """This method, tries to establish an HTTP connection to AWS instance
+        identity document url. If the application is running on an EC2
+        instance, we should be able to get back a valid JSON document. Make a
+        http get request call and store data in local map.
+        This method should only be called once.
+        """
+
+        if cls.inited:
+            return
+
+        content = get_request(_AWS_INSTANCE_IDENTITY_DOCUMENT_URI)
+        if content is not None:
+            content = json.loads(content)
+            for env_var, attribute_key in _AWS_ATTRIBUTES.items():
+                attribute_value = content.get(env_var)
+                if attribute_value is not None:
+                    aws_metadata_map[attribute_key] = attribute_value
+
+            cls.is_running = True
+
+        cls.inited = True
+
+    @classmethod
+    def is_running_on_aws(cls):
+        cls._initialize_aws_identity_document()
+        return cls.is_running
+
+    def get_aws_metadata(self):
+        """AWS Instance Identity Document is a JSON file.
+        See docs.aws.amazon.com/AWSEC2/latest/UserGuide/
+        instance-identity-documents.html.
+        :return:
+        """
+        if self.is_running_on_aws():
+            return aws_metadata_map
+
+        return dict()

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

@@ -0,0 +1,68 @@
+# 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 import resource
+from opencensus.common.monitored_resource import (
+    aws_identity_doc_utils,
+    gcp_metadata_config,
+    k8s_utils,
+)
+
+# Supported environments (resource types)
+_GCE_INSTANCE = "gce_instance"
+_K8S_CONTAINER = "k8s_container"
+_AWS_EC2_INSTANCE = "aws_ec2_instance"
+
+
+def is_gce_environment():
+    """Whether the environment is a virtual machine on GCE."""
+    return gcp_metadata_config.GcpMetadataConfig.is_running_on_gcp()
+
+
+def is_aws_environment():
+    """Whether the environment is a virtual machine instance on EC2."""
+    return aws_identity_doc_utils.AwsIdentityDocumentUtils.is_running_on_aws()
+
+
+def get_instance():
+    """Get a resource based on the application environment.
+
+    Returns a `Resource` configured for the current environment, or None if the
+    environment is unknown or unsupported.
+
+    :rtype: :class:`opencensus.common.resource.Resource` or None
+    :return: A `Resource` configured for the current environment.
+    """
+    resources = []
+    env_resource = resource.get_from_env()
+    if env_resource is not None:
+        resources.append(env_resource)
+
+    if k8s_utils.is_k8s_environment():
+        resources.append(resource.Resource(
+            _K8S_CONTAINER, k8s_utils.get_k8s_metadata()))
+
+    if is_gce_environment():
+        resources.append(resource.Resource(
+            _GCE_INSTANCE,
+            gcp_metadata_config.GcpMetadataConfig().get_gce_metadata()))
+    elif is_aws_environment():
+        resources.append(resource.Resource(
+            _AWS_EC2_INSTANCE,
+            (aws_identity_doc_utils.AwsIdentityDocumentUtils()
+             .get_aws_metadata())))
+
+    if not resources:
+        return None
+    return resource.merge_resources(resources)

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

@@ -0,0 +1,218 @@
+# 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 logging
+import os
+import re
+from copy import copy
+
+logger = logging.getLogger(__name__)
+
+
+OC_RESOURCE_TYPE = 'OC_RESOURCE_TYPE'
+OC_RESOURCE_LABELS = 'OC_RESOURCE_LABELS'
+
+# Matches anything outside ASCII 32-126 inclusive
+_NON_PRINTABLE_ASCII = re.compile(
+    r'[^ !"#$%&\'()*+,\-./:;<=>?@\[\\\]^_`{|}~0-9a-zA-Z]')
+
+# Label key/value tokens, may be quoted
+_WORD_RES = r'(\'[^\']*\'|"[^"]*"|[^\s,=]+)'
+
+_KV_RE = re.compile(r"""
+    \s*                 # ignore leading spaces
+    (?P<key>{word_re})  # capture the key word
+    \s*=\s*
+    (?P<val>{word_re})  # capture the value word
+    \s*                 # ignore trailing spaces
+    """.format(word_re=_WORD_RES), re.VERBOSE)
+
+_LABELS_RE = re.compile(r"""
+    ^\s*{word_re}\s*=\s*{word_re}\s*     # _KV_RE without the named groups
+    (,\s*{word_re}\s*=\s*{word_re}\s*)*  # more KV pairs, comma delimited
+    $
+    """.format(word_re=_WORD_RES), re.VERBOSE)
+
+_UNQUOTE_RE = re.compile(r'^([\'"]?)([^\1]*)(\1)$')
+
+
+def merge_resources(resource_list):
+    """Merge multiple resources to get a new resource.
+
+    Resources earlier in the list take precedence: if multiple resources share
+    a label key, use the value from the first resource in the list with that
+    key. The combined resource's type will be the first non-null type in the
+    list.
+
+    :type resource_list: list(:class:`Resource`)
+    :param resource_list: The list of resources to combine.
+
+    :rtype: :class:`Resource`
+    :return: The new combined resource.
+    """
+    if not resource_list:
+        raise ValueError
+    rtype = None
+    for rr in resource_list:
+        if rr.type:
+            rtype = rr.type
+            break
+    labels = {}
+    for rr in reversed(resource_list):
+        labels.update(rr.labels)
+    return Resource(rtype, labels)
+
+
+def check_ascii_256(string):
+    """Check that `string` is printable ASCII and at most 256 chars.
+
+    Raise a `ValueError` if this check fails. Note that `string` itself doesn't
+    have to be ASCII-encoded.
+
+    :type string: str
+    :param string: The string to check.
+    """
+    if string is None:
+        return
+    if len(string) > 256:
+        raise ValueError("Value is longer than 256 characters")
+    bad_char = _NON_PRINTABLE_ASCII.search(string)
+    if bad_char:
+        raise ValueError(u'Character "{}" at position {} is not printable '
+                         'ASCII'
+                         .format(
+                             string[bad_char.start():bad_char.end()],
+                             bad_char.start()))
+
+
+class Resource(object):
+    """A description of the entity for which signals are reported.
+
+    `type_` and `labels`' keys and values should contain only printable ASCII
+    and should be at most 256 characters.
+
+    See:
+        https://github.com/census-instrumentation/opencensus-specs/blob/master/resource/Resource.md
+
+    :type type_: str
+    :param type_: The resource type identifier.
+
+    :type labels: dict
+    :param labels: Key-value pairs that describe the entity.
+    """  # noqa
+
+    def __init__(self, type_=None, labels=None):
+        if type_ is not None and not type_:
+            raise ValueError("Resource type must not be empty")
+        check_ascii_256(type_)
+        if labels is None:
+            labels = {}
+        for key, value in labels.items():
+            if not key:
+                raise ValueError("Resource key must not be null or empty")
+            if value is None:
+                raise ValueError("Resource value must not be null")
+            check_ascii_256(key)
+            check_ascii_256(value)
+
+        self.type = type_
+        self.labels = copy(labels)
+
+    def get_type(self):
+        """Get this resource's type.
+
+        :rtype: str
+        :return: The resource's type.
+        """
+        return self.type
+
+    def get_labels(self):
+        """Get this resource's labels.
+
+        :rtype: dict
+        :return: The resource's label dict.
+        """
+        return copy(self.labels)
+
+    def merge(self, other):
+        """Get a copy of this resource combined with another resource.
+
+        The combined resource will have the union of both resources' labels,
+        keeping this resource's label values if they conflict.
+
+        :type other: :class:`Resource`
+        :param other: The other resource to merge.
+
+        :rtype: :class:`Resource`
+        :return: The new combined resource.
+        """
+        return merge_resources([self, other])
+
+
+def unquote(string):
+    """Strip quotes surrounding `string` if they exist.
+
+    >>> unquote('abc')
+    'abc'
+    >>> unquote('"abc"')
+    'abc'
+    >>> unquote("'abc'")
+    'abc'
+    >>> unquote('"a\\'b\\'c"')
+    "a'b'c"
+    """
+    return _UNQUOTE_RE.sub(r'\2', string)
+
+
+def parse_labels(labels_str):
+    """Parse label keys and values following the Resource spec.
+
+    >>> parse_labels("k=v")
+    {'k': 'v'}
+    >>> parse_labels("k1=v1, k2=v2")
+    {'k1': 'v1', 'k2': 'v2'}
+    >>> parse_labels("k1='v1,=z1'")
+    {'k1': 'v1,=z1'}
+    """
+    if not _LABELS_RE.match(labels_str):
+        return None
+    labels = {}
+    for kv in _KV_RE.finditer(labels_str):
+        gd = kv.groupdict()
+        key = unquote(gd['key'])
+        if key in labels:
+            logger.warning('Duplicate label key "%s"', key)
+        labels[key] = unquote(gd['val'])
+    return labels
+
+
+def get_from_env():
+    """Get a Resource from environment variables.
+
+    :rtype: :class:`Resource`
+    :return: A resource with type and labels from the environment.
+    """
+    type_env = os.getenv(OC_RESOURCE_TYPE)
+    if type_env is None:
+        return None
+    type_env = type_env.strip()
+
+    labels_env = os.getenv(OC_RESOURCE_LABELS)
+    if labels_env is None:
+        return Resource(type_env)
+
+    labels = parse_labels(labels_env)
+
+    return Resource(type_env, labels)

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

@@ -0,0 +1,177 @@
+# 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.
+
+
+try:
+    import contextvars
+except ImportError:
+    contextvars = None
+
+import threading
+
+__all__ = ['RuntimeContext']
+
+
+class _RuntimeContext(object):
+    @classmethod
+    def clear(cls):
+        """Clear all slots to their default value."""
+
+        raise NotImplementedError  # pragma: NO COVER
+
+    @classmethod
+    def register_slot(cls, name, default=None):
+        """Register a context slot with an optional default value.
+
+        :type name: str
+        :param name: The name of the context slot.
+
+        :type default: object
+        :param name: The default value of the slot, can be a value or lambda.
+
+        :returns: The registered slot.
+        """
+
+        raise NotImplementedError  # pragma: NO COVER
+
+    def apply(self, snapshot):
+        """Set the current context from a given snapshot dictionary"""
+
+        for name in snapshot:
+            setattr(self, name, snapshot[name])
+
+    def snapshot(self):
+        """Return a dictionary of current slots by reference."""
+
+        return dict((n, self._slots[n].get()) for n in self._slots.keys())
+
+    def __repr__(self):
+        return ('{}({})'.format(type(self).__name__, self.snapshot()))
+
+    def __getattr__(self, name):
+        if name not in self._slots:
+            raise AttributeError('{} is not a registered context slot'
+                                 .format(name))
+        slot = self._slots[name]
+        return slot.get()
+
+    def __setattr__(self, name, value):
+        if name not in self._slots:
+            raise AttributeError('{} is not a registered context slot'
+                                 .format(name))
+        slot = self._slots[name]
+        slot.set(value)
+
+    def with_current_context(self, func):
+        """Capture the current context and apply it to the provided func"""
+
+        caller_context = self.snapshot()
+
+        def call_with_current_context(*args, **kwargs):
+            try:
+                backup_context = self.snapshot()
+                self.apply(caller_context)
+                return func(*args, **kwargs)
+            finally:
+                self.apply(backup_context)
+
+        return call_with_current_context
+
+
+class _ThreadLocalRuntimeContext(_RuntimeContext):
+    _lock = threading.Lock()
+    _slots = {}
+
+    class Slot(object):
+        _thread_local = threading.local()
+
+        def __init__(self, name, default):
+            self.name = name
+            self.default = default if callable(default) else (lambda: default)
+
+        def clear(self):
+            setattr(self._thread_local, self.name, self.default())
+
+        def get(self):
+            try:
+                return getattr(self._thread_local, self.name)
+            except AttributeError:
+                value = self.default()
+                self.set(value)
+                return value
+
+        def set(self, value):
+            setattr(self._thread_local, self.name, value)
+
+    @classmethod
+    def clear(cls):
+        with cls._lock:
+            for name in cls._slots:
+                slot = cls._slots[name]
+                slot.clear()
+
+    @classmethod
+    def register_slot(cls, name, default=None):
+        with cls._lock:
+            if name in cls._slots:
+                raise ValueError('slot {} already registered'.format(name))
+            slot = cls.Slot(name, default)
+            cls._slots[name] = slot
+            return slot
+
+
+class _AsyncRuntimeContext(_RuntimeContext):
+    _lock = threading.Lock()
+    _slots = {}
+
+    class Slot(object):
+        def __init__(self, name, default):
+            self.name = name
+            self.contextvar = contextvars.ContextVar(name)
+            self.default = default if callable(default) else (lambda: default)
+
+        def clear(self):
+            self.contextvar.set(self.default())
+
+        def get(self):
+            try:
+                return self.contextvar.get()
+            except LookupError:
+                value = self.default()
+                self.set(value)
+                return value
+
+        def set(self, value):
+            self.contextvar.set(value)
+
+    @classmethod
+    def clear(cls):
+        with cls._lock:
+            for name in cls._slots:
+                slot = cls._slots[name]
+                slot.clear()
+
+    @classmethod
+    def register_slot(cls, name, default=None):
+        with cls._lock:
+            if name in cls._slots:
+                raise ValueError('slot {} already registered'.format(name))
+            slot = cls.Slot(name, default)
+            cls._slots[name] = slot
+            return slot
+
+
+RuntimeContext = _ThreadLocalRuntimeContext()
+if contextvars:
+    RuntimeContext = _AsyncRuntimeContext()

.venv/lib/python3.11/site-packages/opencensus/common/runtime_context/version.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.1.3'

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

@@ -0,0 +1,149 @@
+# 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.
+
+from six.moves import queue
+
+import logging
+import threading
+import time
+
+logger = logging.getLogger(__name__)
+
+
+class PeriodicTask(threading.Thread):
+    """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 kwargs: The kwargs passed in while calling `function`.
+
+    :type name: str
+    :param name: The source of the worker. Used for naming.
+    """
+
+    def __init__(self, interval, function, args=None, kwargs=None, name=None):
+        super(PeriodicTask, self).__init__(name=name)
+        self.interval = interval
+        self.function = function
+        self.args = args or []
+        self.kwargs = kwargs or {}
+        self.finished = threading.Event()
+
+    def run(self):
+        wait_time = self.interval
+        while not self.finished.wait(wait_time):
+            start_time = time.time()
+            self.function(*self.args, **self.kwargs)
+            elapsed_time = time.time() - start_time
+            wait_time = max(self.interval - elapsed_time, 0)
+
+    def cancel(self):
+        self.finished.set()
+
+
+class QueueEvent(object):
+    def __init__(self, name):
+        self.name = name
+        self.event = threading.Event()
+
+    def __repr__(self):
+        return ('{}({})'.format(type(self).__name__, self.name))
+
+    def set(self):
+        return self.event.set()
+
+    def wait(self, timeout=None):
+        return self.event.wait(timeout)
+
+
+class QueueExitEvent(QueueEvent):
+    pass
+
+
+class Queue(object):
+    def __init__(self, capacity):
+        self.EXIT_EVENT = QueueExitEvent('EXIT')
+        self._queue = queue.Queue(maxsize=capacity)
+
+    def _gets(self, count, timeout):
+        start_time = time.time()
+        elapsed_time = 0
+        cnt = 0
+        while cnt < count:
+            try:
+                item = self._queue.get(block=False)
+                yield item
+                if isinstance(item, QueueEvent):
+                    return
+            except queue.Empty:
+                break
+            cnt += 1
+        while cnt < count:
+            wait_time = max(timeout - elapsed_time, 0)
+            try:
+                item = self._queue.get(block=True, timeout=wait_time)
+                yield item
+                if isinstance(item, QueueEvent):
+                    return
+            except queue.Empty:
+                break
+            cnt += 1
+            elapsed_time = time.time() - start_time
+
+    def gets(self, count, timeout):
+        return tuple(self._gets(count, timeout))
+
+    def is_empty(self):
+        return not self._queue.qsize()
+
+    def flush(self, timeout=None):
+        if self._queue.qsize() == 0:
+            return 0
+        start_time = time.time()
+        wait_time = timeout
+        event = QueueEvent('SYNC(timeout={})'.format(wait_time))
+        try:
+            self._queue.put(event, block=True, timeout=wait_time)
+        except queue.Full:
+            return
+        elapsed_time = time.time() - start_time
+        wait_time = timeout and max(timeout - elapsed_time, 0)
+        if event.wait(wait_time):
+            return time.time() - start_time  # time taken to flush
+
+    def put(self, item, block=True, timeout=None):
+        try:
+            self._queue.put(item, block, timeout)
+        except queue.Full:
+            logger.warning('Queue is full. Dropping telemetry.')
+
+    def puts(self, items, block=True, timeout=None):
+        if block and timeout is not None:
+            start_time = time.time()
+            elapsed_time = 0
+            for item in items:
+                wait_time = max(timeout - elapsed_time, 0)
+                self.put(item, block=True, timeout=wait_time)
+                elapsed_time = time.time() - start_time
+        else:
+            for item in items:
+                self.put(item, block, timeout)

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

@@ -0,0 +1,13 @@
+# 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.

.venv/lib/python3.11/site-packages/opencensus/common/transports/async_.py

@@ -0,0 +1,231 @@
+# 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 six.moves import queue, range
+
+import atexit
+import logging
+import threading
+
+from opencensus.common.transports import base
+from opencensus.trace import execution_context
+
+_DEFAULT_GRACE_PERIOD = 5.0  # Seconds
+_DEFAULT_MAX_BATCH_SIZE = 600
+_DEFAULT_WAIT_PERIOD = 60.0  # Seconds
+_WORKER_THREAD_NAME = 'opencensus.common.Worker'
+_WORKER_TERMINATOR = object()
+
+logger = logging.getLogger(__name__)
+
+
+class _Worker(object):
+    """A background thread that exports batches of data.
+
+    :type exporter: :class:`~opencensus.trace.base_exporter.Exporter` or
+                    :class:`~opencensus.stats.base_exporter.StatsExporter`
+    :param exporter: Instance of Exporter object.
+
+    :type grace_period: float
+    :param grace_period: The amount of time to wait for pending data to
+                         be submitted when the process is shutting down.
+
+    :type max_batch_size: int
+    :param max_batch_size: The maximum number of items to send at a time
+                           in the background thread.
+
+    :type wait_period: int
+    :param wait_period: The amount of time to wait before sending the next
+                        batch of data.
+    """
+    def __init__(self, exporter,
+                 grace_period=_DEFAULT_GRACE_PERIOD,
+                 max_batch_size=_DEFAULT_MAX_BATCH_SIZE,
+                 wait_period=_DEFAULT_WAIT_PERIOD):
+        self.exporter = exporter
+        self._grace_period = grace_period
+        self._max_batch_size = max_batch_size
+        self._wait_period = wait_period
+        self._queue = queue.Queue(0)
+        self._lock = threading.Lock()
+        self._event = threading.Event()
+        self._thread = None
+
+    @property
+    def is_alive(self):
+        """Returns True is the background thread is running."""
+        return self._thread is not None and self._thread.is_alive()
+
+    def _get_items(self):
+        """Get multiple items from a Queue.
+
+        Gets at least one (blocking) and at most ``max_batch_size`` items
+        (non-blocking) from a given Queue. Does not mark the items as done.
+
+        :rtype: Sequence
+        :returns: A sequence of items retrieved from the queue.
+        """
+        items = [self._queue.get()]
+
+        while len(items) < self._max_batch_size:
+            try:
+                items.append(self._queue.get_nowait())
+            except queue.Empty:
+                break
+
+        return items
+
+    def _thread_main(self):
+        """The entry point for the worker thread.
+
+        Pulls pending data off the queue and writes them in
+        batches to the specified tracing backend using the exporter.
+        """
+        # Indicate that this thread is an exporter thread.
+        # Used to suppress tracking of requests in this thread
+        execution_context.set_is_exporter(True)
+        quit_ = False
+
+        while True:
+            items = self._get_items()
+            data = []
+
+            for item in items:
+                if item is _WORKER_TERMINATOR:
+                    quit_ = True
+                    # Continue processing items, don't break, try to process
+                    # all items we got back before quitting.
+                else:
+                    data.extend(item)
+
+            if data:
+                try:
+                    self.exporter.emit(data)
+                except Exception:
+                    logger.exception(
+                        '%s failed to emit data.'
+                        'Dropping %s objects from queue.',
+                        self.exporter.__class__.__name__,
+                        len(data))
+                    pass
+
+            for _ in range(len(items)):
+                self._queue.task_done()
+
+            # self._event is set at exit, at which point we start draining the
+            # queue immediately. If self._event is unset, block for
+            # self.wait_period between each batch of exports.
+            self._event.wait(self._wait_period)
+
+            if quit_:
+                break
+
+    def start(self):
+        """Starts the background thread.
+
+        Additionally, this registers a handler for process exit to attempt
+        to send any pending data before shutdown.
+        """
+        with self._lock:
+            if self.is_alive:
+                return
+
+            self._thread = threading.Thread(
+                target=self._thread_main, name=_WORKER_THREAD_NAME)
+            self._thread.daemon = True
+            self._thread.start()
+            atexit.register(self._export_pending_data)
+
+    def stop(self):
+        """Signals the background thread to stop.
+
+        This does not terminate the background thread. It simply queues the
+        stop signal. If the main process exits before the background thread
+        processes the stop signal, it will be terminated without finishing
+        work. The ``grace_period`` parameter will give the background
+        thread some time to finish processing before this function returns.
+
+        :rtype: bool
+        :returns: True if the thread terminated. False if the thread is still
+                  running.
+        """
+        if not self.is_alive:
+            return True
+
+        with self._lock:
+            self._queue.put_nowait(_WORKER_TERMINATOR)
+            self._thread.join(timeout=self._grace_period)
+
+            success = not self.is_alive
+            self._thread = None
+
+            return success
+
+    def _export_pending_data(self):
+        """Callback that attempts to send pending data before termination."""
+        if not self.is_alive:
+            return
+        # Stop blocking between export batches
+        self._event.set()
+        self.stop()
+
+    def enqueue(self, data):
+        """Queues data to be written by the background thread."""
+        self._queue.put_nowait(data)
+
+    def flush(self):
+        """Submit any pending data."""
+        self._queue.join()
+
+
+class AsyncTransport(base.Transport):
+    """Asynchronous transport that uses a background thread.
+
+    :type exporter: :class:`~opencensus.trace.base_exporter.Exporter` or
+                    :class:`~opencensus.stats.base_exporter.StatsExporter`
+    :param exporter: Instance of Exporter object.
+
+    :type grace_period: float
+    :param grace_period: The amount of time to wait for pending data to
+                         be submitted when the process is shutting down.
+
+    :type max_batch_size: int
+    :param max_batch_size: The maximum number of items to send at a time
+                           in the background thread.
+
+    :type wait_period: int
+    :param wait_period: The amount of time to wait before sending the next
+                        batch of data.
+    """
+
+    def __init__(self, exporter,
+                 grace_period=_DEFAULT_GRACE_PERIOD,
+                 max_batch_size=_DEFAULT_MAX_BATCH_SIZE,
+                 wait_period=_DEFAULT_WAIT_PERIOD):
+        self.exporter = exporter
+        self.worker = _Worker(
+            exporter,
+            grace_period,
+            max_batch_size,
+            wait_period,
+        )
+        self.worker.start()
+
+    def export(self, data):
+        """Put the trace/stats to be exported into queue."""
+        self.worker.enqueue(data)
+
+    def flush(self):
+        """Submit any pending traces/stats."""
+        self.worker.flush()

.venv/lib/python3.11/site-packages/opencensus/common/transports/base.py

@@ -0,0 +1,31 @@
+# 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.
+
+"""Module containing base class for transport."""
+
+
+class Transport(object):
+    """Base class for transport.
+
+    Subclasses of :class:`Transport` must override :meth:`export`.
+    """
+    def export(self, datas):
+        """Export the data."""
+        raise NotImplementedError
+
+    def flush(self):
+        """Submit any pending data.
+
+        For blocking/sync transports, this is a no-op.
+        """

.venv/lib/python3.11/site-packages/opencensus/common/transports/sync.py

@@ -0,0 +1,28 @@
+# 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.transports import base
+from opencensus.trace import execution_context
+
+
+class SyncTransport(base.Transport):
+    def __init__(self, exporter):
+        self.exporter = exporter
+
+    def export(self, datas):
+        # Used to suppress tracking of requests in export
+        execution_context.set_is_exporter(True)
+        self.exporter.emit(datas)
+        # Reset the context
+        execution_context.set_is_exporter(False)

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

@@ -0,0 +1,131 @@
+# 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.
+
+try:
+    from weakref import WeakMethod
+except ImportError:
+    from opencensus.common.backports import WeakMethod
+
+import calendar
+import datetime
+import weakref
+
+UTF8 = 'utf-8'
+
+# Max length is 128 bytes for a truncatable string.
+MAX_LENGTH = 128
+
+ISO_DATETIME_REGEX = '%Y-%m-%dT%H:%M:%S.%fZ'
+
+
+def get_truncatable_str(str_to_convert):
+    """Truncate a string if exceed limit and record the truncated bytes
+    count.
+    """
+    truncated, truncated_byte_count = check_str_length(
+        str_to_convert, MAX_LENGTH)
+
+    result = {
+        'value': truncated,
+        'truncated_byte_count': truncated_byte_count,
+    }
+    return result
+
+
+def check_str_length(str_to_check, limit=MAX_LENGTH):
+    """Check the length of a string. If exceeds limit, then truncate it.
+
+    :type str_to_check: str
+    :param str_to_check: String to check.
+
+    :type limit: int
+    :param limit: The upper limit of the length.
+
+    :rtype: tuple
+    :returns: The string it self if not exceeded length, or truncated string
+              if exceeded and the truncated byte count.
+    """
+    str_bytes = str_to_check.encode(UTF8)
+    str_len = len(str_bytes)
+    truncated_byte_count = 0
+
+    if str_len > limit:
+        truncated_byte_count = str_len - limit
+        str_bytes = str_bytes[:limit]
+
+    result = str(str_bytes.decode(UTF8, errors='ignore'))
+
+    return (result, truncated_byte_count)
+
+
+def to_iso_str(ts=None):
+    """Get an ISO 8601 string for a UTC datetime."""
+    if ts is None:
+        ts = datetime.datetime.utcnow()
+    return ts.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+def timestamp_to_microseconds(timestamp):
+    """Convert a timestamp string into a microseconds value
+    :param timestamp
+    :return time in microseconds
+    """
+    timestamp_str = datetime.datetime.strptime(timestamp, ISO_DATETIME_REGEX)
+    epoch_time_secs = calendar.timegm(timestamp_str.timetuple())
+    epoch_time_mus = epoch_time_secs * 1e6 + timestamp_str.microsecond
+    return epoch_time_mus
+
+
+def iuniq(ible):
+    """Get an iterator over unique items of `ible`."""
+    items = set()
+    for item in ible:
+        if item not in items:
+            items.add(item)
+            yield item
+
+
+def uniq(ible):
+    """Get a list of unique items of `ible`."""
+    return list(iuniq(ible))
+
+
+def window(ible, length):
+    """Split `ible` into multiple lists of length `length`.
+
+    >>> list(window(range(5), 2))
+    [[0, 1], [2, 3], [4]]
+    """
+    if length <= 0:  # pragma: NO COVER
+        raise ValueError
+    ible = iter(ible)
+    while True:
+        elts = [xx for ii, xx in zip(range(length), ible)]
+        if elts:
+            yield elts
+        else:
+            break
+
+
+def get_weakref(func):
+    """Get a weak reference to bound or unbound `func`.
+
+    If `func` is unbound (i.e. has no __self__ attr) get a weakref.ref,
+    otherwise get a wrapper that simulates weakref.ref.
+    """
+    if func is None:
+        raise ValueError
+    if not hasattr(func, '__self__'):
+        return weakref.ref(func)
+    return WeakMethod(func)