Add files using upload-large-folder tool

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_event-6.1.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,44 @@
+Zope Public License (ZPL) Version 2.1
+
+A copyright notice accompanies this license document that identifies the
+copyright holders.
+
+This license has been certified as open source. It has also been designated as
+GPL compatible by the Free Software Foundation (FSF).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions in source code must retain the accompanying copyright
+notice, this list of conditions, and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the accompanying copyright
+notice, this list of conditions, and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Names of the copyright holders must not be used to endorse or promote
+products derived from this software without prior written permission from the
+copyright holders.
+
+4. The right to distribute this software or to use it for any purpose does not
+give you the right to use Servicemarks (sm) or Trademarks (tm) of the
+copyright
+holders. Use of them is covered by separate agreement with the copyright
+holders.
+
+5. If any files are modified, you must cause the modified files to carry
+prominent notices stating that you changed the files and the date of any
+change.
+
+Disclaimer
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_event-6.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+zope

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_interface-8.2.dist-info/INSTALLER

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

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_interface-8.2.dist-info/METADATA

@@ -0,0 +1,1288 @@
+Metadata-Version: 2.4
+Name: zope.interface
+Version: 8.2
+Summary: Interfaces for Python
+Author-email: Zope Foundation and contributors <zope-dev@zope.dev>
+Maintainer-email: Plone Foundation and contributors <zope-dev@zope.dev>
+License-Expression: ZPL-2.1
+Project-URL: Documentation, https://zopeinterface.readthedocs.io
+Project-URL: Issues, https://github.com/zopefoundation/zope.interface/issues
+Project-URL: Source, https://github.com/zopefoundation/zope.interface
+Project-URL: Changelog, https://github.com/zopefoundation/zope.interface/blob/master/CHANGES.rst
+Keywords: interface,components,plugins
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE.txt
+Provides-Extra: docs
+Requires-Dist: Sphinx; extra == "docs"
+Requires-Dist: repoze.sphinx.autointerface; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Provides-Extra: test
+Requires-Dist: coverage[toml]; extra == "test"
+Requires-Dist: zope.event; extra == "test"
+Requires-Dist: zope.testing; extra == "test"
+Provides-Extra: testing
+Requires-Dist: coverage[toml]; extra == "testing"
+Requires-Dist: zope.event; extra == "testing"
+Requires-Dist: zope.testing; extra == "testing"
+Dynamic: license-file
+
+====================
+ ``zope.interface``
+====================
+
+.. image:: https://img.shields.io/pypi/v/zope.interface.svg
+    :target: https://pypi.python.org/pypi/zope.interface/
+    :alt: Latest Version
+
+.. image:: https://img.shields.io/pypi/pyversions/zope.interface.svg
+        :target: https://pypi.org/project/zope.interface/
+        :alt: Supported Python versions
+
+.. image:: https://github.com/zopefoundation/zope.interface/actions/workflows/tests.yml/badge.svg
+        :target: https://github.com/zopefoundation/zope.interface/actions/workflows/tests.yml
+
+.. image:: https://readthedocs.org/projects/zopeinterface/badge/?version=latest
+        :target: https://zopeinterface.readthedocs.io/en/latest/
+        :alt: Documentation Status
+
+This package is intended to be independently reusable in any Python
+project. It is maintained by the `Zope Toolkit project
+<https://zopetoolkit.readthedocs.io/>`_.
+
+This package provides an implementation of "object interfaces" for Python.
+Interfaces are a mechanism for labeling objects as conforming to a given
+API or contract. So, this package can be considered as implementation of
+the `Design By Contract`_ methodology support in Python.
+
+.. _Design By Contract: http://en.wikipedia.org/wiki/Design_by_contract
+
+For detailed documentation, please see https://zopeinterface.readthedocs.io/en/latest/
+
+Change log
+==========
+
+8.2 (2026-01-09)
+----------------
+
+- Move all supported package metadata into ``pyproject.toml``.
+
+- Ignore ``__annotate_func__`` added in Python 3.14b1.
+
+
+8.1.1 (2025-11-15)
+------------------
+
+- Fix the GitHub workflow for publishing wheels, which failed for Linux/arm64.
+  (`#348 <https://github.com/zopefoundation/zope.interface/issues/348>`_)
+
+
+8.1 (2025-11-10)
+----------------
+
+- Drop support for Python 3.9.
+
+- Add support for Python 3.14.
+
+
+8.0.1 (2025-09-25)
+------------------
+
+- Make tests resilient against different ways of calling them.
+
+- Remove run-time dependency on ``setuptools``.
+
+
+8.0 (2025-09-12)
+----------------
+
+- Replace ``pkg_resources`` namespace with PEP 420 native namespace.
+
+- Drop support for Python 3.8.
+
+- Allow using newer ``setuptools`` version.
+  (`#333 <https://github.com/zopefoundation/zope.interface/issues/333>`_)
+
+
+7.2 (2024-11-28)
+----------------
+
+- Add preliminary support for Python 3.14a2, this means that
+  ``.common.builtins.IByteString`` and ``.common.collections.IByteString`` are
+  no longer available from this Python version onwards as Python 3.14 dropped
+  ``collections.abc.ByteString``.
+
+
+7.1.1 (2024-10-23)
+------------------
+
+- Fix segmentation faults in `weakrefobject.c` on Python 3.12 and 3.13.
+  (`#323 <https://github.com/zopefoundation/zope.interface/issues/323>`_)
+
+
+7.1.0 (2024-10-10)
+------------------
+
+- Declare support for Python 3.13.
+
+- Fix segmentation faults on Python 3.13.
+  (`#323 <https://github.com/zopefoundation/zope.interface/issues/323>`_)
+
+
+7.0.3 (2024-08-27)
+------------------
+
+- Fix `Assertion 'memb->type -- T_PYSSIZET' failed.` for Python < 3.12.
+  (`#319 <https://github.com/zopefoundation/zope.interface/issues/319>`_)
+
+
+7.0.2 (2024-08-26)
+------------------
+
+- Fix reference-counting bug in C module initialization (broken in 7.0).
+  (`#316 <https://github.com/zopefoundation/zope.interface/issues/316>`_)
+
+
+7.0.1 (2024-08-06)
+------------------
+
+- Fix subclassability of ``ObjectSpecificationDescriptor`` (broken in 7.0).
+  (`#312 <https://github.com/zopefoundation/zope.interface/issues/312>`_)
+
+
+7.0 (2024-08-06)
+----------------
+
+- Enable heap-based types (PEP 384) for Python >= 3.11.
+
+- Adopt multi-phase module initialization (PEP 489).
+
+- Drop support for Python 3.7.
+
+
+6.4.post2 (2024-05-24)
+----------------------
+
+- Publish missing Windows wheels, second attempt.
+  (`#295 <https://github.com/zopefoundation/zope.interface/issues/295>`_)
+
+
+6.4.post1 (2024-05-23)
+----------------------
+
+- Publish missing Windows wheels.
+  (`#295 <https://github.com/zopefoundation/zope.interface/issues/295>`_)
+
+
+6.4.post0 (2024-05-22)
+----------------------
+
+- The sdist of version 6.4 was uploaded to PyPI as
+  ``zope_interface-6.4.tar.gz`` instead of ``zope.interface-6.4-py2.tar.gz``
+  which cannot be installed by ``zc.buildout``.  This release is a re-release
+  of version 6.4 with the correct sdist name.
+  (`#298 <https://github.com/zopefoundation/zope.interface/issues/298>`_)
+
+
+6.4 (2024-05-15)
+----------------
+
+- Adjust for incompatible changes in Python 3.13b1.
+  (`#292 <https://github.com/zopefoundation/zope.interface/issues/292>`_)
+
+- Build windows wheels on GHA.
+
+
+6.3 (2024-04-12)
+----------------
+
+- Add preliminary support for Python 3.13 as of 3.13a6.
+
+
+6.2 (2024-02-16)
+----------------
+
+- Add preliminary support for Python 3.13 as of 3.13a3.
+
+- Add support to use the pipe (``|``) syntax for ``typing.Union``.
+  (`#280 <https://github.com/zopefoundation/zope.interface/issues/280>`_)
+
+
+6.1 (2023-10-05)
+----------------
+
+- Build Linux binary wheels for Python 3.12.
+
+- Add support for Python 3.12.
+
+- Fix building of the docs for non-final versions.
+
+
+6.0 (2023-03-17)
+----------------
+
+- Build Linux binary wheels for Python 3.11.
+
+- Drop support for Python 2.7, 3.5, 3.6.
+
+- Fix test deprecation warning on Python 3.11.
+
+- Add preliminary support for Python 3.12 as of 3.12a5.
+
+- Drop:
+
+    + `zope.interface.implements`
+    + `zope.interface.implementsOnly`
+    + `zope.interface.classProvides`
+
+
+5.5.2 (2022-11-17)
+------------------
+
+- Add support for building arm64 wheels on macOS.
+
+
+5.5.1 (2022-11-03)
+------------------
+
+- Add support for final Python 3.11 release.
+
+
+5.5.0 (2022-10-10)
+------------------
+
+- Add support for Python 3.10 and 3.11 (as of 3.11.0rc2).
+
+- Add missing Trove classifier showing support for Python 3.9.
+
+- Add some more entries to ``zope.interface.interfaces.__all__``.
+
+- Disable unsafe math optimizations in C code.  See `pull request 262
+  <https://github.com/zopefoundation/zope.interface/pull/262>`_.
+
+
+5.4.0 (2021-04-15)
+------------------
+
+- Make the C implementation of the ``__providedBy__`` descriptor stop
+  ignoring all errors raised when accessing the instance's
+  ``__provides__``. Now it behaves like the Python version and only
+  catches ``AttributeError``. The previous behaviour could lead to
+  crashing the interpreter in cases of recursion and errors. See
+  `issue 239 <https://github.com/zopefoundation/zope.interface/issues>`_.
+
+- Update the ``repr()`` and ``str()`` of various objects to be shorter
+  and more informative. In many cases, the ``repr()`` is now something
+  that can be evaluated to produce an equal object. For example, what
+  was previously printed as ``<implementedBy builtins.list>`` is now
+  shown as ``classImplements(list, IMutableSequence, IIterable)``. See
+  `issue 236 <https://github.com/zopefoundation/zope.interface/issues/236>`_.
+
+- Make ``Declaration.__add__`` (as in ``implementedBy(Cls) +
+  ISomething``) try harder to preserve a consistent resolution order
+  when the two arguments share overlapping pieces of the interface
+  inheritance hierarchy. Previously, the right hand side was always
+  put at the end of the resolution order, which could easily produce
+  invalid orders. See `issue 193
+  <https://github.com/zopefoundation/zope.interface/issues/193>`_.
+
+
+5.3.0 (2020-03-21)
+------------------
+
+- No changes from 5.3.0a1
+
+
+5.3.0a1 (2021-03-18)
+--------------------
+
+- Improve the repr of ``zope.interface.Provides`` to remove ambiguity
+  about what is being provided. This is especially helpful diagnosing
+  IRO issues.
+
+- Allow subclasses of ``BaseAdapterRegistry`` (including
+  ``AdapterRegistry`` and ``VerifyingAdapterRegistry``) to have
+  control over the data structures. This allows persistent
+  implementations such as those based on ZODB to choose more scalable
+  options (e.g., BTrees instead of dicts). See `issue 224
+  <https://github.com/zopefoundation/zope.interface/issues/224>`_.
+
+- Fix a reference counting issue in ``BaseAdapterRegistry`` that could
+  lead to references to interfaces being kept around even when all
+  utilities/adapters/subscribers providing that interface have been
+  removed. This is mostly an issue for persistent implementations.
+  Note that this only corrects the issue moving forward, it does not
+  solve any already corrupted reference counts. See `issue 227
+  <https://github.com/zopefoundation/zope.interface/issues/227>`_.
+
+- Add the method ``BaseAdapterRegistry.rebuild()``. This can be used
+  to fix the reference counting issue mentioned above, as well as to
+  update the data structures when custom data types have changed.
+
+- Add the interface method ``IAdapterRegistry.subscribed()`` and
+  implementation ``BaseAdapterRegistry.subscribed()`` for querying
+  directly registered subscribers. See `issue 230
+  <https://github.com/zopefoundation/zope.interface/issues/230>`_.
+
+- Add the maintenance method
+  ``Components.rebuildUtilityRegistryFromLocalCache()``. Most users
+  will not need this, but it can be useful if the ``Components.utilities``
+  registry is suspected to be out of sync with the ``Components``
+  object itself (this might happen to persistent ``Components``
+  implementations in the face of bugs).
+
+- Fix the ``Provides`` and ``ClassProvides`` descriptors to stop
+  allowing redundant interfaces (those already implemented by the
+  underlying class or meta class) to produce an inconsistent
+  resolution order. This is similar to the change in ``@implementer``
+  in 5.1.0, and resolves inconsistent resolution orders with
+  ``zope.proxy`` and ``zope.location``. See `issue 207
+  <https://github.com/zopefoundation/zope.interface/issues/207>`_.
+
+
+5.2.0 (2020-11-05)
+------------------
+
+- Add documentation section ``Persistency and Equality``
+  (`#218 <https://github.com/zopefoundation/zope.interface/issues/218>`_).
+
+- Create arm64 wheels.
+
+- Add support for Python 3.9.
+
+
+5.1.2 (2020-10-01)
+------------------
+
+- Make sure to call each invariant only once when validating invariants.
+  Previously, invariants could be called multiple times because when an
+  invariant is defined in an interface, it's found by in all interfaces
+  inheriting from that interface.  See `pull request 215
+  <https://github.com/zopefoundation/zope.interface/pull/215/>`_.
+
+
+5.1.1 (2020-09-30)
+------------------
+
+- Fix the method definitions of ``IAdapterRegistry.subscribe``,
+  ``subscriptions`` and ``subscribers``. Previously, they all were
+  defined to accept a ``name`` keyword argument, but subscribers have
+  no names and the implementation of that interface did not accept
+  that argument. See `issue 208
+  <https://github.com/zopefoundation/zope.interface/issues/208>`_.
+
+- Fix a potential reference leak in the C optimizations. Previously,
+  applications that dynamically created unique ``Specification``
+  objects (e.g., used ``@implementer`` on dynamic classes) could
+  notice a growth of small objects over time leading to increased
+  garbage collection times. See `issue 216
+  <https://github.com/zopefoundation/zope.interface/issues/216>`_.
+
+  .. caution::
+
+     This leak could prevent interfaces used as the bases of
+     other interfaces from being garbage collected. Those interfaces
+     will now be collected.
+
+     One way in which this would manifest was that ``weakref.ref``
+     objects (and things built upon them, like
+     ``Weak[Key|Value]Dictionary``) would continue to have access to
+     the original object even if there were no other visible
+     references to Python and the original object *should* have been
+     collected. This could be especially problematic for the
+     ``WeakKeyDictionary`` when combined with dynamic or local
+     (created in the scope of a function) interfaces, since interfaces
+     are hashed based just on their name and module name. See the
+     linked issue for an example of a resulting ``KeyError``.
+
+     Note that such potential errors are not new, they are just once
+     again a possibility.
+
+
+5.1.0 (2020-04-08)
+------------------
+
+- Make ``@implementer(*iface)`` and ``classImplements(cls, *iface)``
+  ignore redundant interfaces. If the class already implements an
+  interface through inheritance, it is no longer redeclared
+  specifically for *cls*. This solves many instances of inconsistent
+  resolution orders, while still allowing the interface to be declared
+  for readability and maintenance purposes. See `issue 199
+  <https://github.com/zopefoundation/zope.interface/issues/199>`_.
+
+- Remove all bare ``except:`` statements. Previously, when accessing
+  special attributes such as ``__provides__``, ``__providedBy__``,
+  ``__class__`` and ``__conform__``, this package wrapped such access
+  in a bare ``except:`` statement, meaning that many errors could pass
+  silently; typically this would result in a fallback path being taken
+  and sometimes (like with ``providedBy()``) the result would be
+  non-sensical. This is especially true when those attributes are
+  implemented with descriptors. Now, only ``AttributeError`` is
+  caught. This makes errors more obvious.
+
+  Obviously, this means that some exceptions will be propagated
+  differently than before. In particular, ``RuntimeError`` raised by
+  Acquisition in the case of circular containment will now be
+  propagated. Previously, when adapting such a broken object, a
+  ``TypeError`` would be the common result, but now it will be a more
+  informative ``RuntimeError``.
+
+  In addition, ZODB errors like ``POSKeyError`` could now be
+  propagated where previously they would ignored by this package.
+
+  See `issue 200 <https://github.com/zopefoundation/zope.interface/issues/200>`_.
+
+- Require that the second argument (*bases*) to ``InterfaceClass`` is
+  a tuple. This only matters when directly using ``InterfaceClass`` to
+  create new interfaces dynamically. Previously, an individual
+  interface was allowed, but did not work correctly. Now it is
+  consistent with ``type`` and requires a tuple.
+
+- Let interfaces define custom ``__adapt__`` methods. This implements
+  the other side of the :pep:`246` adaptation protocol: objects being
+  adapted could already implement ``__conform__`` if they know about
+  the interface, and now interfaces can implement ``__adapt__`` if
+  they know about particular objects. There is no performance penalty
+  for interfaces that do not supply custom ``__adapt__`` methods.
+
+  This includes the ability to add new methods, or override existing
+  interface methods using the new ``@interfacemethod`` decorator.
+
+  See `issue 3 <https://github.com/zopefoundation/zope.interface/issues/3>`_.
+
+- Make the internal singleton object returned by APIs like
+  ``implementedBy`` and ``directlyProvidedBy`` for objects that
+  implement or provide no interfaces more immutable. Previously an
+  internal cache could be mutated. See `issue 204
+  <https://github.com/zopefoundation/zope.interface/issues/204>`_.
+
+
+5.0.2 (2020-03-30)
+------------------
+
+- Ensure that objects that implement no interfaces (such as direct
+  subclasses of ``object``) still include ``Interface`` itself in
+  their ``__iro___`` and ``__sro___``. This fixes adapter registry
+  lookups for such objects when the adapter is registered for
+  ``Interface``. See `issue 197
+  <https://github.com/zopefoundation/zope.interface/issues/197>`_.
+
+
+5.0.1 (2020-03-21)
+------------------
+
+- Ensure the resolution order for ``InterfaceClass`` is consistent.
+  See `issue 192 <https://github.com/zopefoundation/zope.interface/issues/192>`_.
+
+- Ensure the resolution order for ``collections.OrderedDict`` is
+  consistent on CPython 2. (It was already consistent on Python 3 and PyPy).
+
+- Fix the handling of the ``ZOPE_INTERFACE_STRICT_IRO`` environment
+  variable. Previously, ``ZOPE_INTERFACE_STRICT_RO`` was read, in
+  contrast with the documentation. See `issue 194
+  <https://github.com/zopefoundation/zope.interface/issues/194>`_.
+
+
+5.0.0 (2020-03-19)
+------------------
+
+- Make an internal singleton object returned by APIs like
+  ``implementedBy`` and ``directlyProvidedBy`` immutable. Previously,
+  it was fully mutable and allowed changing its ``__bases___``. That
+  could potentially lead to wrong results in pathological corner
+  cases. See `issue 158
+  <https://github.com/zopefoundation/zope.interface/issues/158>`_.
+
+- Support the ``PURE_PYTHON`` environment variable at runtime instead
+  of just at wheel build time. A value of 0 forces the C extensions to
+  be used (even on PyPy) failing if they aren't present. Any other
+  value forces the Python implementation to be used, ignoring the C
+  extensions. See `PR 151 <https://github.com/zopefoundation/zope.interface/pull/151>`_.
+
+- Cache the result of ``__hash__`` method in ``InterfaceClass`` as a
+  speed optimization. The method is called very often (i.e several
+  hundred thousand times during Plone 5.2 startup). Because the hash value never
+  changes it can be cached. This improves test performance from 0.614s
+  down to 0.575s (1.07x faster). In a real world Plone case a reindex
+  index came down from 402s to 320s (1.26x faster). See `PR 156
+  <https://github.com/zopefoundation/zope.interface/pull/156>`_.
+
+- Change the C classes ``SpecificationBase`` and its subclass
+  ``ClassProvidesBase`` to store implementation attributes in their structures
+  instead of their instance dictionaries. This eliminates the use of
+  an undocumented private C API function, and helps make some
+  instances require less memory. See `PR 154 <https://github.com/zopefoundation/zope.interface/pull/154>`_.
+
+- Reduce memory usage in other ways based on observations of usage
+  patterns in Zope (3) and Plone code bases.
+
+  - Specifications with no dependents are common (more than 50%) so
+    avoid allocating a ``WeakKeyDictionary`` unless we need it.
+  - Likewise, tagged values are relatively rare, so don't allocate a
+    dictionary to hold them until they are used.
+  - Use ``__slots___`` or the C equivalent ``tp_members`` in more
+    common places. Note that this removes the ability to set arbitrary
+    instance variables on certain objects.
+    See `PR 155 <https://github.com/zopefoundation/zope.interface/pull/155>`_.
+
+  The changes in this release resulted in a 7% memory reduction after
+  loading about 6,000 modules that define about 2,200 interfaces.
+
+  .. caution::
+
+     Details of many private attributes have changed, and external use
+     of those private attributes may break. In particular, the
+     lifetime and default value of ``_v_attrs`` has changed.
+
+- Remove support for hashing uninitialized interfaces. This could only
+  be done by subclassing ``InterfaceClass``. This has generated a
+  warning since it was first added in 2011 (3.6.5). Please call the
+  ``InterfaceClass`` constructor or otherwise set the appropriate
+  fields in your subclass before attempting to hash or sort it. See
+  `issue 157 <https://github.com/zopefoundation/zope.interface/issues/157>`_.
+
+- Remove unneeded override of the ``__hash__`` method from
+  ``zope.interface.declarations.Implements``. Watching a reindex index
+  process in ZCatalog with on a Py-Spy after 10k samples the time for
+  ``.adapter._lookup`` was reduced from 27.5s to 18.8s (~1.5x faster).
+  Overall reindex index time shrunk from 369s to 293s (1.26x faster).
+  See `PR 161
+  <https://github.com/zopefoundation/zope.interface/pull/161>`_.
+
+- Make the Python implementation closer to the C implementation by
+  ignoring all exceptions, not just ``AttributeError``, during (parts
+  of) interface adaptation. See `issue 163
+  <https://github.com/zopefoundation/zope.interface/issues/163>`_.
+
+- Micro-optimization in ``.adapter._lookup`` , ``.adapter._lookupAll``
+  and ``.adapter._subscriptions``: By loading ``components.get`` into
+  a local variable before entering the loop a bytcode "LOAD_FAST 0
+  (components)" in the loop can be eliminated. In Plone, while running
+  all tests, average speedup of the "owntime" of ``_lookup`` is ~5x.
+  See `PR 167
+  <https://github.com/zopefoundation/zope.interface/pull/167>`_.
+
+- Add ``__all__`` declarations to all modules. This helps tools that
+  do auto-completion and documentation and results in less cluttered
+  results. Wildcard ("*") are not recommended and may be affected. See
+  `issue 153
+  <https://github.com/zopefoundation/zope.interface/issues/153>`_.
+
+- Fix ``verifyClass`` and ``verifyObject`` for builtin types like
+  ``dict`` that have methods taking an optional, unnamed argument with
+  no default value like ``dict.pop``. On PyPy3, the verification is
+  strict, but on PyPy2 (as on all versions of CPython) those methods
+  cannot be verified and are ignored. See `issue 118
+  <https://github.com/zopefoundation/zope.interface/issues/118>`_.
+
+- Update the common interfaces ``IEnumerableMapping``,
+  ``IExtendedReadMapping``, ``IExtendedWriteMapping``,
+  ``IReadSequence`` and ``IUniqueMemberWriteSequence`` to no longer
+  require methods that were removed from Python 3 on Python 3, such as
+  ``__setslice___``. Now, ``dict``, ``list`` and ``tuple`` properly
+  verify as ``IFullMapping``, ``ISequence`` and ``IReadSequence,``
+  respectively on all versions of Python.
+
+- Add human-readable ``__str___`` and ``__repr___`` to ``Attribute``
+  and ``Method``. These contain the name of the defining interface
+  and the attribute. For methods, it also includes the signature.
+
+- Change the error strings raised by ``verifyObject`` and
+  ``verifyClass``. They now include more human-readable information
+  and exclude extraneous lines and spaces. See `issue 170
+  <https://github.com/zopefoundation/zope.interface/issues/170>`_.
+
+  .. caution:: This will break consumers (such as doctests) that
+               depended on the exact error messages.
+
+- Make ``verifyObject`` and ``verifyClass`` report all errors, if the
+  candidate object has multiple detectable violations. Previously they
+  reported only the first error. See `issue
+  <https://github.com/zopefoundation/zope.interface/issues/171>`_.
+
+  Like the above, this will break consumers depending on the exact
+  output of error messages if more than one error is present.
+
+- Add ``zope.interface.common.collections``,
+  ``zope.interface.common.numbers``, and ``zope.interface.common.io``.
+  These modules define interfaces based on the ABCs defined in the
+  standard library ``collections.abc``, ``numbers`` and ``io``
+  modules, respectively. Importing these modules will make the
+  standard library concrete classes that are registered with those
+  ABCs declare the appropriate interface. See `issue 138
+  <https://github.com/zopefoundation/zope.interface/issues/138>`_.
+
+- Add ``zope.interface.common.builtins``. This module defines
+  interfaces of common builtin types, such as ``ITextString`` and
+  ``IByteString``, ``IDict``, etc. These interfaces extend the
+  appropriate interfaces from ``collections`` and ``numbers``, and the
+  standard library classes implement them after importing this module.
+  This is intended as a replacement for third-party packages like
+  `dolmen.builtins <https://pypi.org/project/dolmen.builtins/>`_.
+  See `issue 138 <https://github.com/zopefoundation/zope.interface/issues/138>`_.
+
+- Make ``providedBy()`` and ``implementedBy()`` respect ``super``
+  objects. For instance, if class ``Derived`` implements ``IDerived``
+  and extends ``Base`` which in turn implements ``IBase``, then
+  ``providedBy(super(Derived, derived))`` will return ``[IBase]``.
+  Previously it would have returned ``[IDerived]`` (in general, it
+  would previously have returned whatever would have been returned
+  without ``super``).
+
+  Along with this change, adapter registries will unpack ``super``
+  objects into their ``__self___`` before passing it to the factory.
+  Together, this means that ``component.getAdapter(super(Derived,
+  self), ITarget)`` is now meaningful.
+
+  See `issue 11 <https://github.com/zopefoundation/zope.interface/issues/11>`_.
+
+- Fix a potential interpreter crash in the low-level adapter
+  registry lookup functions. See issue 11.
+
+- Adopt Python's standard `C3 resolution order
+  <https://www.python.org/download/releases/2.3/mro/>`_ to compute the
+  ``__iro__`` and ``__sro__`` of interfaces, with tweaks to support
+  additional cases that are common in interfaces but disallowed for
+  Python classes. Previously, an ad-hoc ordering that made no
+  particular guarantees was used.
+
+  This has many beneficial properties, including the fact that base
+  interface and base classes tend to appear near the end of the
+  resolution order instead of the beginning. The resolution order in
+  general should be more predictable and consistent.
+
+  .. caution::
+     In some cases, especially with complex interface inheritance
+     trees or when manually providing or implementing interfaces, the
+     resulting IRO may be quite different. This may affect adapter
+     lookup.
+
+  The C3 order enforces some constraints in order to be able to
+  guarantee a sensible ordering. Older versions of zope.interface did
+  not impose similar constraints, so it was possible to create
+  interfaces and declarations that are inconsistent with the C3
+  constraints. In that event, zope.interface will still produce a
+  resolution order equal to the old order, but it won't be guaranteed
+  to be fully C3 compliant. In the future, strict enforcement of C3
+  order may be the default.
+
+  A set of environment variables and module constants allows
+  controlling several aspects of this new behaviour. It is possible to
+  request warnings about inconsistent resolution orders encountered,
+  and even to forbid them. Differences between the C3 resolution order
+  and the previous order can be logged, and, in extreme cases, the
+  previous order can still be used (this ability will be removed in
+  the future). For details, see the documentation for
+  ``zope.interface.ro``.
+
+- Make inherited tagged values in interfaces respect the resolution
+  order (``__iro__``), as method and attribute lookup does. Previously
+  tagged values could give inconsistent results. See `issue 190
+  <https://github.com/zopefoundation/zope.interface/issues/190>`_.
+
+- Add ``getDirectTaggedValue`` (and related methods) to interfaces to
+  allow accessing tagged values irrespective of inheritance. See
+  `issue 190
+  <https://github.com/zopefoundation/zope.interface/issues/190>`_.
+
+- Ensure that ``Interface`` is always the last item in the ``__iro__``
+  and ``__sro__``. This is usually the case, but if classes that do
+  not implement any interfaces are part of a class inheritance
+  hierarchy, ``Interface`` could be assigned too high a priority.
+  See `issue 8 <https://github.com/zopefoundation/zope.interface/issues/8>`_.
+
+- Implement sorting, equality, and hashing in C for ``Interface``
+  objects. In micro benchmarks, this makes those operations 40% to 80%
+  faster. This translates to a 20% speed up in querying adapters.
+
+  Note that this changes certain implementation details. In
+  particular, ``InterfaceClass`` now has a non-default metaclass, and
+  it is enforced that ``__module__`` in instances of
+  ``InterfaceClass`` is read-only.
+
+  See `PR 183 <https://github.com/zopefoundation/zope.interface/pull/183>`_.
+
+
+4.7.2 (2020-03-10)
+------------------
+
+- Remove deprecated use of setuptools features.  See `issue 30
+  <https://github.com/zopefoundation/zope.interface/issues/30>`_.
+
+
+4.7.1 (2019-11-11)
+------------------
+
+- Use Python 3 syntax in the documentation.  See `issue 119
+  <https://github.com/zopefoundation/zope.interface/issues/119>`_.
+
+
+4.7.0 (2019-11-11)
+------------------
+
+- Drop support for Python 3.4.
+
+- Change ``queryTaggedValue``, ``getTaggedValue``,
+  ``getTaggedValueTags`` in interfaces. They now include inherited
+  values by following ``__bases__``. See `PR 144
+  <https://github.com/zopefoundation/zope.interface/pull/144>`_.
+
+  .. caution:: This may be a breaking change.
+
+- Add support for Python 3.8.
+
+
+4.6.0 (2018-10-23)
+------------------
+
+- Add support for Python 3.7
+
+- Fix ``verifyObject`` for class objects with staticmethods on
+  Python 3. See `issue 126
+  <https://github.com/zopefoundation/zope.interface/issues/126>`_.
+
+
+4.5.0 (2018-04-19)
+------------------
+
+- Drop support for 3.3, avoid accidental dependence breakage via setup.py.
+  See `PR 110 <https://github.com/zopefoundation/zope.interface/pull/110>`_.
+- Allow registering and unregistering instance methods as listeners.
+  See `issue 12 <https://github.com/zopefoundation/zope.interface/issues/12>`_
+  and `PR 102 <https://github.com/zopefoundation/zope.interface/pull/102>`_.
+- Synchronize and simplify zope/__init__.py. See `issue 114
+  <https://github.com/zopefoundation/zope.interface/issues/114>`_
+
+
+4.4.3 (2017-09-22)
+------------------
+
+- Avoid exceptions when the ``__annotations__`` attribute is added to
+  interface definitions with Python 3.x type hints. See `issue 98
+  <https://github.com/zopefoundation/zope.interface/issues/98>`_.
+- Fix the possibility of a rare crash in the C extension when
+  deallocating items. See `issue 100
+  <https://github.com/zopefoundation/zope.interface/issues/100>`_.
+
+
+4.4.2 (2017-06-14)
+------------------
+
+- Fix a regression storing
+  ``zope.component.persistentregistry.PersistentRegistry`` instances.
+  See `issue 85 <https://github.com/zopefoundation/zope.interface/issues/85>`_.
+
+- Fix a regression that could lead to the utility registration cache
+  of ``Components`` getting out of sync. See `issue 93
+  <https://github.com/zopefoundation/zope.interface/issues/93>`_.
+
+
+4.4.1 (2017-05-13)
+------------------
+
+- Simplify the caching of utility-registration data. In addition to
+  simplification, avoids spurious test failures when checking for
+  leaks in tests with persistent registries. See `pull 84
+  <https://github.com/zopefoundation/zope.interface/pull/84>`_.
+
+- Raise ``ValueError`` when non-text names are passed to adapter registry
+  methods:  prevents corruption of lookup caches.
+
+
+4.4.0 (2017-04-21)
+------------------
+
+- Avoid a warning from the C compiler.
+  (https://github.com/zopefoundation/zope.interface/issues/71)
+
+- Add support for Python 3.6.
+
+
+4.3.3 (2016-12-13)
+------------------
+
+- Correct typos and ReST formatting errors in documentation.
+
+- Add API documentation for the adapter registry.
+
+- Ensure that the ``LICENSE.txt`` file is included in built wheels.
+
+- Fix C optimizations broken on Py3k.  See the Python bug at:
+  http://bugs.python.org/issue15657
+  (https://github.com/zopefoundation/zope.interface/issues/60)
+
+
+4.3.2 (2016-09-05)
+------------------
+
+- Fix equality testing of ``implementedBy`` objects and proxies.
+  (https://github.com/zopefoundation/zope.interface/issues/55)
+
+
+4.3.1 (2016-08-31)
+------------------
+
+- Support Components subclasses that are not hashable.
+  (https://github.com/zopefoundation/zope.interface/issues/53)
+
+
+4.3.0 (2016-08-31)
+------------------
+
+- Add the ability to sort the objects returned by ``implementedBy``.
+  This is compatible with the way interface classes sort so they can
+  be used together in ordered containers like BTrees.
+  (https://github.com/zopefoundation/zope.interface/issues/42)
+
+- Make ``setuptools`` a hard dependency of ``setup.py``.
+  (https://github.com/zopefoundation/zope.interface/issues/13)
+
+- Change a linear algorithm (O(n)) in ``Components.registerUtility`` and
+  ``Components.unregisterUtility`` into a dictionary lookup (O(1)) for
+  hashable components. This substantially improves the time taken to
+  manipulate utilities in large registries at the cost of some
+  additional memory usage. (https://github.com/zopefoundation/zope.interface/issues/46)
+
+
+4.2.0 (2016-06-10)
+------------------
+
+- Add support for Python 3.5
+
+- Drop support for Python 2.6 and 3.2.
+
+
+4.1.3 (2015-10-05)
+------------------
+
+- Fix installation without a C compiler on Python 3.5
+  (https://github.com/zopefoundation/zope.interface/issues/24).
+
+
+4.1.2 (2014-12-27)
+------------------
+
+- Add support for PyPy3.
+
+- Remove unittest assertions deprecated in Python3.x.
+
+- Add ``zope.interface.document.asReStructuredText``, which formats the
+  generated text for an interface using ReST double-backtick markers.
+
+
+4.1.1 (2014-03-19)
+------------------
+
+- Add support for Python 3.4.
+
+
+4.1.0 (2014-02-05)
+------------------
+
+- Update ``boostrap.py`` to version 2.2.
+
+- Add ``@named(name)`` declaration, that specifies the component name, so it
+  does not have to be passed in during registration.
+
+
+4.0.5 (2013-02-28)
+------------------
+
+- Fix a bug where a decorated method caused false positive failures on
+  ``verifyClass()``.
+
+
+4.0.4 (2013-02-21)
+------------------
+
+- Fix a bug that was revealed by porting zope.traversing. During a loop, the
+  loop body modified a weakref dict causing a ``RuntimeError`` error.
+
+
+4.0.3 (2012-12-31)
+------------------
+
+- Fleshed out PyPI Trove classifiers.
+
+
+4.0.2 (2012-11-21)
+------------------
+
+- Add support for Python 3.3.
+
+- Restored ability to install the package in the absence of ``setuptools``.
+
+- LP #1055223:  Fix test which depended on dictionary order and failed randomly
+  in Python 3.3.
+
+
+4.0.1 (2012-05-22)
+------------------
+
+- Drop explicit ``DeprecationWarnings`` for "class advice" APIS (these
+  APIs are still deprecated under Python 2.x, and still raise an exception
+  under Python 3.x, but no longer cause a warning to be emitted under
+  Python 2.x).
+
+
+4.0.0 (2012-05-16)
+------------------
+
+- Automated build of Sphinx HTML docs and running doctest snippets via tox.
+
+- Deprecate the "class advice" APIs from ``zope.interface.declarations``:
+  ``implements``, ``implementsOnly``, and ``classProvides``.  In their place,
+  prefer the equivalent class decorators: ``@implementer``,
+  ``@implementer_only``, and ``@provider``.  Code which uses the deprecated
+  APIs will not work as expected under Py3k.
+
+- Remove use of '2to3' and associated fixers when installing under Py3k.
+  The code is now in a "compatible subset" which supports Python 2.6, 2.7,
+  and 3.2, including PyPy 1.8 (the version compatible with the 2.7 language
+  spec).
+
+- Drop explicit support for Python 2.4 / 2.5 / 3.1.
+
+- Add support for PyPy.
+
+- Add support for continuous integration using ``tox`` and ``jenkins``.
+
+- Add 'setup.py dev' alias (runs ``setup.py develop`` plus installs
+  ``nose`` and ``coverage``).
+
+- Add 'setup.py docs' alias (installs ``Sphinx`` and dependencies).
+
+- Replace all unittest coverage previously accomplished via doctests with
+  unittests.  The doctests have been moved into a ``docs`` section, managed
+  as a Sphinx collection.
+
+- LP #910987:  Ensure that the semantics of the ``lookup`` method of
+  ``zope.interface.adapter.LookupBase`` are the same in both the C and
+  Python implementations.
+
+- LP #900906:  Avoid exceptions due to tne new ``__qualname__`` attribute
+  added in Python 3.3 (see PEP 3155 for rationale).  Thanks to Antoine
+  Pitrou for the patch.
+
+
+3.8.0 (2011-09-22)
+------------------
+
+- New module ``zope.interface.registry``.  This is code moved from
+  ``zope.component.registry`` which implements a basic nonperistent component
+  registry as ``zope.interface.registry.Components``.  This class was moved
+  from ``zope.component`` to make porting systems (such as Pyramid) that rely
+  only on a basic component registry to Python 3 possible without needing to
+  port the entirety of the ``zope.component`` package.  Backwards
+  compatibility import shims have been left behind in ``zope.component``, so
+  this change will not break any existing code.
+
+- New ``tests_require`` dependency: ``zope.event`` to test events sent by
+  Components implementation.  The ``zope.interface`` package does not have a
+  hard dependency on ``zope.event``, but if ``zope.event`` is importable, it
+  will send component registration events when methods of an instance of
+  ``zope.interface.registry.Components`` are called.
+
+- New interfaces added to support ``zope.interface.registry.Components``
+  addition: ``ComponentLookupError``, ``Invalid``, ``IObjectEvent``,
+  ``ObjectEvent``, ``IComponentLookup``, ``IRegistration``,
+  ``IUtilityRegistration``, ``IAdapterRegistration``,
+  ``ISubscriptionAdapterRegistration``, ``IHandlerRegistration``,
+  ``IRegistrationEvent``, ``RegistrationEvent``, ``IRegistered``,
+  ``Registered``, ``IUnregistered``, ``Unregistered``,
+  ``IComponentRegistry``, and ``IComponents``.
+
+- No longer Python 2.4 compatible (tested under 2.5, 2.6, 2.7, and 3.2).
+
+
+3.7.0 (2011-08-13)
+------------------
+
+- Move changes from 3.6.2 - 3.6.5 to a new 3.7.x release line.
+
+
+3.6.7 (2011-08-20)
+------------------
+
+- Fix sporadic failures on x86-64 platforms in tests of rich comparisons
+  of interfaces.
+
+
+3.6.6 (2011-08-13)
+------------------
+
+- LP #570942:  Now correctly compare interfaces  from different modules but
+  with the same names.
+
+  N.B.: This is a less intrusive / destabilizing fix than the one applied in
+  3.6.3:  we only fix the underlying cmp-alike function, rather than adding
+  the other "rich comparison" functions.
+
+- Revert to software as released with 3.6.1 for "stable" 3.6 release branch.
+
+
+3.6.5 (2011-08-11)
+------------------
+
+- LP #811792:  work around buggy behavior in some subclasses of
+  ``zope.interface.interface.InterfaceClass``, which invoke ``__hash__``
+  before initializing ``__module__`` and ``__name__``.  The workaround
+  returns a fixed constant hash in such cases, and issues a ``UserWarning``.
+
+- LP #804832:  Under PyPy, ``zope.interface`` should not build its C
+  extension.  Also, prevent attempting to build it under Jython.
+
+- Add a tox.ini for easier xplatform testing.
+
+- Fix testing deprecation warnings issued when tested under Py3K.
+
+
+3.6.4 (2011-07-04)
+------------------
+
+- LP 804951:  InterfaceClass instances were unhashable under Python 3.x.
+
+
+3.6.3 (2011-05-26)
+------------------
+
+- LP #570942:  Now correctly compare interfaces  from different modules but
+  with the same names.
+
+
+3.6.2 (2011-05-17)
+------------------
+
+- Moved detailed documentation out-of-line from PyPI page, linking instead to
+  http://docs.zope.org/zope.interface .
+
+- Fixes for small issues when running tests under Python 3.2 using
+  ``zope.testrunner``.
+
+- LP # 675064:  Specify return value type for C optimizations module init
+  under Python 3:  undeclared value caused warnings, and segfaults on some
+  64 bit architectures.
+
+- setup.py now raises RuntimeError if you don't have Distutils installed when
+  running under Python 3.
+
+
+3.6.1 (2010-05-03)
+------------------
+
+- A non-ASCII character in the changelog made 3.6.0 uninstallable on
+  Python 3 systems with another default encoding than UTF-8.
+
+- Fix compiler warnings under GCC 4.3.3.
+
+
+3.6.0 (2010-04-29)
+------------------
+
+- LP #185974:  Clear the cache used by ``Specificaton.get`` inside
+  ``Specification.changed``.  Thanks to Jacob Holm for the patch.
+
+- Add support for Python 3.1. Contributors:
+
+    Lennart Regebro
+    Martin v Loewis
+    Thomas Lotze
+    Wolfgang Schnerring
+
+  The 3.1 support is completely backwards compatible. However, the implements
+  syntax used under Python 2.X does not work under 3.X, since it depends on
+  how metaclasses are implemented and this has changed. Instead it now supports
+  a decorator syntax (also under Python 2.X)::
+
+    class Foo:
+        implements(IFoo)
+        ...
+
+  can now also be written::
+
+    @implementer(IFoo):
+    class Foo:
+        ...
+
+  There are 2to3 fixers available to do this change automatically in the
+  zope.fixers package.
+
+- Python 2.3 is no longer supported.
+
+
+3.5.4 (2009-12-23)
+------------------
+
+- Use the standard Python doctest module instead of zope.testing.doctest, which
+  has been deprecated.
+
+
+3.5.3 (2009-12-08)
+------------------
+
+- Fix an edge case: make providedBy() work when a class has '__provides__' in
+  its __slots__ (see http://thread.gmane.org/gmane.comp.web.zope.devel/22490)
+
+
+3.5.2 (2009-07-01)
+------------------
+
+- BaseAdapterRegistry.unregister, unsubscribe: Remove empty portions of
+  the data structures when something is removed.  This avoids leaving
+  references to global objects (interfaces) that may be slated for
+  removal from the calling application.
+
+
+3.5.1 (2009-03-18)
+------------------
+
+- verifyObject: use getattr instead of hasattr to test for object attributes
+  in order to let exceptions other than AttributeError raised by properties
+  propagate to the caller
+
+- Add Sphinx-based documentation building to the package buildout
+  configuration. Use the ``bin/docs`` command after buildout.
+
+- Improve package description a bit. Unify changelog entries formatting.
+
+- Change package's mailing list address to zope-dev at zope.org as
+  zope3-dev at zope.org is now retired.
+
+
+3.5.0 (2008-10-26)
+------------------
+
+- Fix declaration of _zope_interface_coptimizations, it's not a top level
+  package.
+
+- Add a DocTestSuite for odd.py module, so their tests are run.
+
+- Allow to bootstrap on Jython.
+
+- Fix https://bugs.launchpad.net/zope3/3.3/+bug/98388: ISpecification
+  was missing a declaration for __iro__.
+
+- Add optional code optimizations support, which allows the building
+  of C code optimizations to fail (Jython).
+
+- Replace `_flatten` with a non-recursive implementation, effectively making
+  it 3x faster.
+
+
+3.4.1 (2007-10-02)
+------------------
+
+- Fix a setup bug that prevented installation from source on systems
+  without setuptools.
+
+
+3.4.0 (2007-07-19)
+------------------
+
+- Final release for 3.4.0.
+
+
+3.4.0b3 (2007-05-22)
+--------------------
+
+
+- When checking whether an object is already registered, use identity
+  comparison, to allow adding registering with picky custom comparison methods.
+
+
+3.3.0.1 (2007-01-03)
+--------------------
+
+- Made a reference to OverflowWarning, which disappeared in Python
+  2.5, conditional.
+
+
+3.3.0 (2007/01/03)
+------------------
+
+New Features
+------------
+
+- Refactor the adapter-lookup algorithim to make it much simpler and faster.
+
+  Also, implement more of the adapter-lookup logic in C, making
+  debugging of application code easier, since there is less
+  infrastructre code to step through.
+
+- Treat objects without interface declarations as if they
+  declared that they provide ``zope.interface.Interface``.
+
+- Add a number of richer new adapter-registration interfaces
+  that provide greater control and introspection.
+
+- Add a new interface decorator to zope.interface that allows the
+  setting of tagged values on an interface at definition time (see
+  zope.interface.taggedValue).
+
+Bug Fixes
+---------
+
+- A bug in multi-adapter lookup sometimes caused incorrect adapters to
+  be returned.
+
+
+3.2.0.2 (2006-04-15)
+--------------------
+
+- Fix packaging bug:  'package_dir' must be a *relative* path.
+
+
+3.2.0.1 (2006-04-14)
+--------------------
+
+- Packaging change:  suppress inclusion of 'setup.cfg' in 'sdist' builds.
+
+
+3.2.0 (2006-01-05)
+------------------
+
+- Corresponds to the version of the zope.interface package shipped as part of
+  the Zope 3.2.0 release.
+
+
+3.1.0 (2005-10-03)
+------------------
+
+- Corresponds to the version of the zope.interface package shipped as part of
+  the Zope 3.1.0 release.
+
+- Made attribute resolution order consistent with component lookup order,
+  i.e. new-style class MRO semantics.
+
+- Deprecate 'isImplementedBy' and 'isImplementedByInstancesOf' APIs in
+  favor of 'implementedBy' and 'providedBy'.
+
+
+3.0.1 (2005-07-27)
+------------------
+
+- Corresponds to the version of the zope.interface package shipped as part of
+  the Zope X3.0.1 release.
+
+- Fix a bug reported by James Knight, which caused adapter registries
+  to fail occasionally to reflect declaration changes.
+
+
+3.0.0 (2004-11-07)
+------------------
+
+- Corresponds to the version of the zope.interface package shipped as part of
+  the Zope X3.0.0 release.

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_interface-8.2.dist-info/RECORD

@@ -0,0 +1,108 @@
+zope/interface/__init__.py,sha256=9Euz0jFaHg3kT84m2HzikMt7s_JIAjM8BlVctyUfNTk,3475
+zope/interface/__pycache__/__init__.cpython-310.pyc,,
+zope/interface/__pycache__/_compat.cpython-310.pyc,,
+zope/interface/__pycache__/_flatten.cpython-310.pyc,,
+zope/interface/__pycache__/adapter.cpython-310.pyc,,
+zope/interface/__pycache__/advice.cpython-310.pyc,,
+zope/interface/__pycache__/declarations.cpython-310.pyc,,
+zope/interface/__pycache__/document.cpython-310.pyc,,
+zope/interface/__pycache__/exceptions.cpython-310.pyc,,
+zope/interface/__pycache__/interface.cpython-310.pyc,,
+zope/interface/__pycache__/interfaces.cpython-310.pyc,,
+zope/interface/__pycache__/registry.cpython-310.pyc,,
+zope/interface/__pycache__/ro.cpython-310.pyc,,
+zope/interface/__pycache__/verify.cpython-310.pyc,,
+zope/interface/_compat.py,sha256=8FPCPdRAl2Mlkc45-FBvuN8i1kvYLEkIionVgjk2AP0,4413
+zope/interface/_flatten.py,sha256=NKviK4ZyLBCjxXvz5voI9pV_ui2SLqUhubbqZkvgEcg,1059
+zope/interface/_zope_interface_coptimizations.c,sha256=oCYrpT2efApCO-EbKs71YXyaSohAbTqdWQ7QEh49SNA,71198
+zope/interface/_zope_interface_coptimizations.cpython-310-x86_64-linux-gnu.so,sha256=fL-GPybY5zXa7KJX1h9knqbxounbao8cR2hZ054Bjz8,186360
+zope/interface/adapter.py,sha256=XN9PD8OrRmP1ZJy2gPvAMXtiOnKcHL34doH0HaKHguQ,36647
+zope/interface/advice.py,sha256=YftOBzbXuWQ3AuJImMtYv4SYbE7ubJrjodXzTgYR-dk,3918
+zope/interface/common/__init__.py,sha256=ho-q_3jeKVq-jO-5xrN9_Q4PR0o8PDwja5NYsO7qTI0,10644
+zope/interface/common/__pycache__/__init__.cpython-310.pyc,,
+zope/interface/common/__pycache__/builtins.cpython-310.pyc,,
+zope/interface/common/__pycache__/collections.cpython-310.pyc,,
+zope/interface/common/__pycache__/idatetime.cpython-310.pyc,,
+zope/interface/common/__pycache__/interfaces.cpython-310.pyc,,
+zope/interface/common/__pycache__/io.cpython-310.pyc,,
+zope/interface/common/__pycache__/mapping.cpython-310.pyc,,
+zope/interface/common/__pycache__/numbers.cpython-310.pyc,,
+zope/interface/common/__pycache__/sequence.cpython-310.pyc,,
+zope/interface/common/builtins.py,sha256=WRHf0D-xo2yWu4uP0zvpISdfuwBqwFFYiYuPLNiIYvQ,3135
+zope/interface/common/collections.py,sha256=duvGnbFpUHwri5idqhYblEJrdDYuUvL3vIsZtXggQC4,6809
+zope/interface/common/idatetime.py,sha256=sn5ccP9CiQAYzn6mptWf05uInZFp9o_DRu9_MaDXM5c,21039
+zope/interface/common/interfaces.py,sha256=fT2pigpAZuqcm0bqVVNDlvSWtv9oKfsJ73ewrymUpIE,5908
+zope/interface/common/io.py,sha256=if6Yzclu_T7qeUQNsXeIqREqgVTu-rjYB_VGZfYyz3Y,1242
+zope/interface/common/mapping.py,sha256=XI9lO7Uwt_9sWDFyhDIk0Rjcr5nlu7SlD2KDyqdupdw,4687
+zope/interface/common/numbers.py,sha256=D4kUnF5OgAk6CKcxaW86VH_OPLh1OXt_cF6WaOfvjLk,1682
+zope/interface/common/sequence.py,sha256=SYvqSZpKRaX11vCADK6zGn0LqogPQ0u7INbqgTJ4sg8,5531
+zope/interface/common/tests/__init__.py,sha256=Am8tpD6HZQx6pfW7N22-dloC83-dKLA45NiM9Lx7Xss,5553
+zope/interface/common/tests/__pycache__/__init__.cpython-310.pyc,,
+zope/interface/common/tests/__pycache__/basemapping.cpython-310.pyc,,
+zope/interface/common/tests/__pycache__/test_builtins.cpython-310.pyc,,
+zope/interface/common/tests/__pycache__/test_collections.cpython-310.pyc,,
+zope/interface/common/tests/__pycache__/test_idatetime.cpython-310.pyc,,
+zope/interface/common/tests/__pycache__/test_import_interfaces.cpython-310.pyc,,
+zope/interface/common/tests/__pycache__/test_io.cpython-310.pyc,,
+zope/interface/common/tests/__pycache__/test_numbers.cpython-310.pyc,,
+zope/interface/common/tests/basemapping.py,sha256=iitIJEMm7LlS3vQU51RjoN3AeBUNNf0EGLXi_VklJAs,3768
+zope/interface/common/tests/test_builtins.py,sha256=eftbVFY5-e7r310YTuf6LlL1Jl5HJ0EXTWZ2icAmrnY,1485
+zope/interface/common/tests/test_collections.py,sha256=XlATWN4tuHLpl_4o0eocWiPV7GGFu5xH3RUN0fPZs0s,5829
+zope/interface/common/tests/test_idatetime.py,sha256=qGr8FDbiVuDZHjyDIKcz7Vz6qNfoFzd9eHejMTfIyAg,1923
+zope/interface/common/tests/test_import_interfaces.py,sha256=wCFk-2kc7r-kAeOXZn5th5Qw_6k_-pMvdguk5b4NstM,813
+zope/interface/common/tests/test_io.py,sha256=gYJnFT52De1JAJruKK6dzyQIdLgYdQME9Yn6QTn2QyI,1686
+zope/interface/common/tests/test_numbers.py,sha256=tPrvkFVYa2kSSxf8_j7XYctupfS4BI-ee_jQ5yU8zRM,1395
+zope/interface/declarations.py,sha256=csCgY3nsiTjpkjdHs53DJGoeIGSeI_mUaTISYQB_9dQ,43512
+zope/interface/document.py,sha256=mhSCJoxw7Whl-q-EMSkys--z3C7IyJ6TEsZ3psMqyJE,4139
+zope/interface/exceptions.py,sha256=lW7SnsOT73LZI8w3aRdCRVUubfSy-CGztchnKqv1-5A,8566
+zope/interface/interface.py,sha256=IXDKNZL0W_qG9nHYwXZ4RVhrMC-pkW5arnbbxrhJo38,39859
+zope/interface/interfaces.py,sha256=9abPucc_lYWpELDFt28wnbjRVtQ8pS48srV8toZmLgk,50268
+zope/interface/registry.py,sha256=eDnfUtTFp1z9f-4F-4ZQ9EATLheAYuCP9_coZ3XLdVw,25812
+zope/interface/ro.py,sha256=NeImEPsautGBC1VtQAQ1J1BGXmksw6hoSNWD7gVmEaQ,24577
+zope/interface/tests/__init__.py,sha256=Vu2CALgC5nADbRAZFb99LcDSXECcPCNdJDL-nv_6mZA,4242
+zope/interface/tests/__pycache__/__init__.cpython-310.pyc,,
+zope/interface/tests/__pycache__/advisory_testing.cpython-310.pyc,,
+zope/interface/tests/__pycache__/dummy.cpython-310.pyc,,
+zope/interface/tests/__pycache__/idummy.cpython-310.pyc,,
+zope/interface/tests/__pycache__/m1.cpython-310.pyc,,
+zope/interface/tests/__pycache__/odd.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_adapter.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_advice.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_compile_flags.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_declarations.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_document.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_element.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_exceptions.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_interface.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_interfaces.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_odd_declarations.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_registry.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_ro.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_sorting.cpython-310.pyc,,
+zope/interface/tests/__pycache__/test_verify.cpython-310.pyc,,
+zope/interface/tests/advisory_testing.py,sha256=T2XF0DT8t9zi1JxnvR1u0WXpRtyOn5027VMyEcN7Ldc,900
+zope/interface/tests/dummy.py,sha256=dd_cYIiPvYJDrEMQD0m2cl9SpkVMrQzMMu1yglSrnb8,913
+zope/interface/tests/idummy.py,sha256=ESC_l4UqjCkiCeXWfcphVGtrP7PoNwwTTGzLpp6Doo4,890
+zope/interface/tests/m1.py,sha256=clhSXmtaT8liCnM87Kp0bzAHfxIxr6gUBjXnVuxaUNI,850
+zope/interface/tests/odd.py,sha256=nwjmxbHCFuI2UvY3Pwc7CfkmZWfXsn3oCb7r7C34DxU,2967
+zope/interface/tests/test_adapter.py,sha256=pB3Y_oXXtdtDsKf0BYlvpW281nT1yendxtzWgWp9o_0,80508
+zope/interface/tests/test_advice.py,sha256=gFhlbHvSWuC9kdlBPeXO_8_9ihkSU-ih0pVhoocdp4U,6036
+zope/interface/tests/test_compile_flags.py,sha256=wU3vtmqgzll6HMPbzFErMpORoVghrcZ5krIV4x6rfo4,1290
+zope/interface/tests/test_declarations.py,sha256=gzATuEoy4KZLB3gyZDV6YD5yv5hdVaBqJIRMFdC2U7E,79081
+zope/interface/tests/test_document.py,sha256=0JIYe0GWvDPkr_IBACPw-8HsHNJyNNHBU_lUHYOXd9M,17220
+zope/interface/tests/test_element.py,sha256=z9Q2hYwPVzMX05NpA_IeiHoAb4qhTiHI57XQI38w4zQ,1120
+zope/interface/tests/test_exceptions.py,sha256=axXG_D_Ug3wdk1r3C_4dHOsOF4h-IvTt1RFyJfkAUz8,6495
+zope/interface/tests/test_interface.py,sha256=aWQAkBNgvA2M_s-gPac1XOwpi5ltkcDFy5KHyy2Gga0,93419
+zope/interface/tests/test_interfaces.py,sha256=l4SCfUmVfBO1UoZLsTOOvDyoYUM7Wex3J67uR7taFpQ,4395
+zope/interface/tests/test_odd_declarations.py,sha256=0DBSBIoOUdSRcDnhiScexGhZ2mVydYWnlJOBvny76Uo,7660
+zope/interface/tests/test_registry.py,sha256=8CyxRkJ46ITauSGp86y1gSN4KHvZNVPTVKgjD13aXBk,112599
+zope/interface/tests/test_ro.py,sha256=Z1K4CbcTkTtuEOc3y3ceXLsKjwkmO_GqYqqwzqFgvms,15257
+zope/interface/tests/test_sorting.py,sha256=-lMIltkIv7Dxu_HRuYtsa6HXVf1fk_jM0gUYHEvj0ac,2222
+zope/interface/tests/test_verify.py,sha256=JnVLFlHGgVn8fC6u-WPW-mDtfmSuDA2PC0sglWuVBjI,19200
+zope/interface/verify.py,sha256=cEaIWPcS6gT97RkQW2SQJxxuUP7wRrwYwsJtXqo8jdE,7333
+zope_interface-8.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+zope_interface-8.2.dist-info/METADATA,sha256=D9pYt0cVkYFNPORUIJYIH82HONTG8GJaz1Hr9j7PbQc,45392
+zope_interface-8.2.dist-info/RECORD,,
+zope_interface-8.2.dist-info/WHEEL,sha256=Aiu96bhtsfzw3NvQvzxQNkf7f9Xl2wW2dtqHpSc6fW0,224
+zope_interface-8.2.dist-info/licenses/LICENSE.txt,sha256=PmcdsR32h1FswdtbPWXkqjg-rKPCDOo_r1Og9zNdCjw,2070
+zope_interface-8.2.dist-info/top_level.txt,sha256=QpUHvpO4wIuZDeEgKY8qZCtD-tAukB0fn_f6utzlb98,5

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_interface-8.2.dist-info/WHEEL

@@ -0,0 +1,8 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-manylinux_2_5_x86_64
+Tag: cp310-cp310-manylinux1_x86_64
+Tag: cp310-cp310-manylinux_2_17_x86_64
+Tag: cp310-cp310-manylinux2014_x86_64
+

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_interface-8.2.dist-info/licenses/LICENSE.txt

@@ -0,0 +1,44 @@
+Zope Public License (ZPL) Version 2.1
+
+A copyright notice accompanies this license document that identifies the
+copyright holders.
+
+This license has been certified as open source. It has also been designated as
+GPL compatible by the Free Software Foundation (FSF).
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions in source code must retain the accompanying copyright
+notice, this list of conditions, and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the accompanying copyright
+notice, this list of conditions, and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+3. Names of the copyright holders must not be used to endorse or promote
+products derived from this software without prior written permission from the
+copyright holders.
+
+4. The right to distribute this software or to use it for any purpose does not
+give you the right to use Servicemarks (sm) or Trademarks (tm) of the
+copyright
+holders. Use of them is covered by separate agreement with the copyright
+holders.
+
+5. If any files are modified, you must cause the modified files to carry
+prominent notices stating that you changed the files and the date of any
+change.
+
+Disclaimer
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED
+OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

miniconda3/envs/ladir/lib/python3.10/site-packages/zope_interface-8.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+zope

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/__init__.py

@@ -0,0 +1,23 @@
+from .__version__ import __version__
+from .exception import ZtiJwtError
+from .zti_jwt_helper import (
+    ZTIJwtHelper,
+    jwt_helper,
+    is_token_zti,
+    decode_jwt_svid,
+    decode_gdpr_or_jwt_svid,
+)
+
+__author__ = "Jeff Li"
+__email__ = "jeff.li@byteddance.com"
+
+
+__all__ = [
+    "__version__",
+    "ZtiJwtError",
+    "ZTIJwtHelper",
+    "jwt_helper",
+    "is_token_zti",
+    "decode_jwt_svid",
+    "decode_gdpr_or_jwt_svid",
+]

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/__version__.py

@@ -0,0 +1,3 @@
+VERSION = (0, 0, 24)
+
+__version__ = ".".join(map(str, VERSION))

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/exception.py

@@ -0,0 +1,4 @@
+class ZtiJwtError(Exception):
+    def __init__(self, message=None):
+        Exception.__init__(self, message)
+        self.message = message

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/memfd.py

@@ -0,0 +1,40 @@
+import io
+import os
+from .rw_lock import RWLock
+
+try:
+    from bytedmemfd import memfd
+except ImportError:
+    memfd = None
+
+MEMFD_DEFAULT_NAME = "zti_jwt_helper"
+
+class Memfd(object):
+    def __init__(self):
+        self.lock = RWLock()
+        self.memfd_fd = None
+
+    def unwrap_memfd(self):
+        if memfd is None or self.memfd_fd is None:
+            return
+        try:
+            self.lock.lock()
+            os.close(self.memfd_fd)
+        finally:
+            self.lock.un_lock()
+
+    def write_content_to_memfd(self, content):
+        if memfd is None:
+            return
+        try:
+            self.lock.lock()
+            if self.memfd_fd is not None:
+                os.close(self.memfd_fd)
+                self.memfd_fd = None
+            self.memfd_fd = memfd.memfd_create(MEMFD_DEFAULT_NAME, memfd.MFD_ALLOW_SEALING)
+            with io.open(self.memfd_fd, mode="wb+", buffering=0, closefd=False) as f:
+                f.write(content)
+                f.seek(0)
+            memfd.addseals(self.memfd_fd, memfd.F_SEAL_ALL)
+        finally:
+            self.lock.un_lock()

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/metric.py

@@ -0,0 +1,41 @@
+import logging
+
+from bytedance import metrics
+from ztijwthelper.__version__ import __version__
+
+logger = logging.getLogger(__name__)
+ZTI_METRICS_PREFIX = "security.zti.jwt_helper"
+GET_TOKEN_FAILED = "get_token_error"
+GET_TOKEN_SUCCEED = "get_token"
+GET_TOKEN_FROM_STRING = "get_token_from_string"
+FETCH_TOKEN_FROM_PATH_FAILED = "fetch_token_path_error"
+GET_TOKEN_FROM_AGENT_FAIL = "get_token_from_agent_fail"
+
+# backward compatible with dps agent: need to deprecate in future version
+GET_TOKEN_FROM_DPS_AGENT_SUCCEED = "get_token_from_dps_agent"
+GET_TOKEN_FROM_DPS_AGENT_FAIL = "get_token_from_dps_agent_fail"
+
+
+class MetricsClient(object):
+    def __init__(self):
+        self.mcli = metrics.Client(prefix=ZTI_METRICS_PREFIX)
+
+    def count(self, metric_name, **kwargs):
+        if metric_name == "":
+            return
+        try:
+            kwargs.update(
+                {
+                    "ver": __version__,
+                    "language": "python",
+                }
+            )
+            self.mcli.emit_counter(metric_name, 1, tags=kwargs)
+        except Exception as e:
+            logger.error("jwt metric emit count failed: {}".format(e))
+
+    def flush(self):
+        self.mcli.flush()
+
+
+metrics_client = MetricsClient()

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/models.py

@@ -0,0 +1,183 @@
+# coding: utf-8
+
+import time
+import jwt
+from .spiffe_id import ID
+
+
+class ZeroTrustIdentity(object):
+    def __init__(
+        self,
+        spiffe_id=None,
+        expiry=None,
+        namespace=None,
+        region=None,
+        vdc=None,
+        identity=None,
+        legacy_id=None,
+    ):
+        self.spiffeID = spiffe_id
+        self.expiry = expiry
+        self.namespace = namespace
+        self.region = region
+        self.vdc = vdc
+        self.id = identity
+        self.legacyID = legacy_id
+
+    def __str__(self):
+        return (
+            "{ From str method of ZeroTrustIdentity: spiffeID = %s, "
+            "expiry = %s, namespace = %s, region = %s, "
+            "vdc = %s, id = %s, legacyID = %s }"
+            % (
+                self.spiffeID,
+                self.expiry,
+                self.namespace,
+                self.region,
+                self.vdc,
+                self.id,
+                self.legacyID,
+            )
+        )
+
+    def get_id(self):
+        return self.id
+
+    def map2identity(self, params):
+        spiffe_id_str = params.get("sub")
+        self.spiffeID = ID().from_str(spiffe_id_str)
+        self.expiry = params.get("exp")
+        legid_map = params.get("legid")
+        if legid_map:
+            self.legacyID = LegacyIdentity(**legid_map)
+        else:
+            self.legacyID = None
+
+        for schemas in self.spiffeID.get_path().split("/"):
+            schema = schemas.split(":")
+            if len(schema) != 2:
+                continue
+            if schema[0].lower() == "id":
+                self.id = schema[1]
+            if schema[0].lower() == "r":
+                self.region = schema[1]
+            if schema[0].lower() == "vdc":
+                self.vdc = schema[1]
+            if schema[0].lower() == "ns":
+                self.namespace = schema[1]
+        return self
+
+    def get_legacy_identity_from_zti(self):
+        if self.legacyID is not None:
+            return self.legacyID
+        # build up a new legacy identity from zti
+        identity = LegacyIdentity(
+            version=0, authority=self.namespace, expireTime=self.expiry
+        )
+        if self.namespace == "user":
+            identity.primary_auth_type = "user"
+            identity.user = self.id
+        else:
+            identity.primary_auth_type = "psm"
+            identity.psm = self.id
+        return identity
+
+
+class LegacyIdentity(object):
+    def __init__(self, **kwargs):
+        self.version = kwargs.get("version")
+        self.authority = kwargs.get("authority")
+        self.authority_chain = kwargs.get("authorityChain")
+        self.primary_auth_type = kwargs.get("primaryAuthType")
+        self.psm = kwargs.get("psm")
+        self.user = kwargs.get("user")
+        self.expire_time = kwargs.get("expireTime")
+        self.extension = kwargs.get("extension")
+
+    def __str__(self):
+        return (
+            "{ From str method of LegacyIdentity: version = %s, "
+            "authority = %s, authorityChain = %s, primaryAuthType = %s, "
+            "psm = %s, user = %s, expireTime = %s, "
+            "extension = %s }"
+            % (
+                self.version,
+                self.authority,
+                self.authority_chain,
+                self.primary_auth_type,
+                self.psm,
+                self.user,
+                self.expire_time,
+                self.extension,
+            )
+        )
+
+    def to_json(self):
+        return {
+            "version": self.version,
+            "authority": self.authority,
+            "authorityChain": self.authority_chain or [],
+            "primaryAuthType": self.primary_auth_type,
+            "psm": self.psm,
+            "user": self.user,
+            "expireTime": str(self.expire_time),
+            "extension": self.extension or {},
+        }
+
+class SyncInformation(object):
+    def __init__(self, token, token_source):
+        self.last_sync_time = time.strftime(
+            "%Y-%m-%dT%H:%M:%S.000000000%z", time.localtime()
+        )
+        self.token_source = token_source
+        header = jwt.get_unverified_header(token)
+        if "kid" not in header:
+            self.token_type = "gdpr"
+            claims = jwt.decode(token, verify=False, options={"verify_signature": False})
+            self.legacy_identity = LegacyIdentity(**claims)
+            return
+        claim = jwt.decode(
+            token,
+            options={
+                "verify_signature": False,
+                "verify_aud": False,
+                "verify_exp": False,
+            },
+        )
+        zti = ZeroTrustIdentity().map2identity(claim)
+        self.token_type = "zti"
+
+        self.legacy_identity = zti.get_legacy_identity_from_zti()
+        self.key_id = header["kid"]
+        self.trust_domain = zti.spiffeID.get_trust_domain()
+
+    def __str__(self):
+        return (
+            "{ From str method of SyncInformation: tokenType = %s, "
+            " tokenSource = %s, lastSyncTime = %s, keyID = %s, "
+            "trustDomain = %s, legacyIdentity = %s }"
+            % (
+                self.token_type,
+                self.token_source,
+                self.last_sync_time,
+                self.key_id,
+                self.trust_domain,
+                self.legacy_identity,
+            )
+        )
+
+    def to_json(self):
+        if self.token_type == "gdpr":
+            return {
+                "tokenType": self.token_type,
+                "tokenSource": self.token_source,
+                "lastSyncTime": self.last_sync_time,
+            }
+        return {
+            "tokenType": self.token_type,
+            "tokenSource": self.token_source,
+            "lastSyncTime": self.last_sync_time,
+            "keyID": self.key_id,
+            "trustDomain": self.trust_domain,
+            "legacyIdentity": self.legacy_identity.to_json(),
+        }

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/rw_lock.py

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+import threading
+
+
+class RWLock(object):
+    def __init__(self):
+        self.__monitor = threading.Lock()
+        self.__exclude = threading.Lock()
+        self.readers = 0
+
+    def r_lock(self):
+        with self.__monitor:
+            self.readers += 1
+            if self.readers == 1:
+                self.__exclude.acquire()
+
+    def r_un_lock(self):
+        with self.__monitor:
+            self.readers -= 1
+            if self.readers == 0:
+                self.__exclude.release()
+
+    def lock(self):
+        self.__exclude.acquire()
+
+    def un_lock(self):
+        self.__exclude.release()

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/spiffe_id.py

@@ -0,0 +1,35 @@
+from urllib3.util import url
+
+
+class ID(object):
+    def __init__(self, trust_domain=None, path=None):
+        self.trust_domain = trust_domain
+        self.path = path
+
+    def __str__(self):
+        return "{ From str method of ID: trust_domain = %s, path = %s }" % (
+            self.trust_domain,
+            self.path,
+        )
+
+    def from_str(self, id_str):
+        uri = url.parse_url(id_str)
+        self.trust_domain = str(uri.hostname)
+        self.path = str(uri.path).lstrip("/").rstrip("/")
+        return self
+
+    def is_zero(self):
+        if not self.trust_domain:
+            return True
+        return False
+
+    def to_str(self):
+        if self.is_zero():
+            return ""
+        return self.trust_domain + "/" + self.path
+
+    def get_trust_domain(self):
+        return str(self.trust_domain)
+
+    def get_path(self):
+        return str(self.path)

miniconda3/envs/ladir/lib/python3.10/site-packages/ztijwthelper/zti_jwt_helper.py

@@ -0,0 +1,478 @@
+import stat
+import threading
+from .models import ZeroTrustIdentity, LegacyIdentity, SyncInformation
+from .rw_lock import RWLock
+from .exception import ZtiJwtError
+from ztispiffe.spire.api.workload import JWTClientConfig, JWTClient
+from .memfd import Memfd
+from .metric import (
+    metrics_client,
+    GET_TOKEN_FROM_STRING,
+    FETCH_TOKEN_FROM_PATH_FAILED,
+    GET_TOKEN_FROM_AGENT_FAIL,
+    GET_TOKEN_FAILED,
+    GET_TOKEN_SUCCEED,
+    GET_TOKEN_FROM_DPS_AGENT_SUCCEED,
+    GET_TOKEN_FROM_DPS_AGENT_FAIL,
+)
+
+json_lib = True
+try:
+    import ujson as json
+except ImportError:
+    try:
+        import json
+    except ImportError:
+        try:
+            import simplejson as json
+        except ImportError:
+            json_lib = False
+
+import os
+import socket
+import time
+import logging
+import jwt
+import bytedenv
+import six
+from deprecated import deprecated
+
+_LOGGER = logging.getLogger(__name__)
+DEFAULT_AGENT_SOCKET_PATH = [
+    "/var/run/zti-agent.sock",
+    "/var/run/zti-agent/sockets/agent.sock",
+]
+DEFAULT_TIMEOUT_SECONDS = 5
+SEC_TOKEN_PATH = "SEC_TOKEN_PATH"
+SEC_TOKEN_STRING = "SEC_TOKEN_STRING"
+ZTI_AGENT_SOCKET_PATH = "ZTI_AGENT_SOCKET_PATH"
+METADATA = [("workload.spiffe.io", "true")]
+
+# backward compatible with dps agent: need to deprecate in future version
+DPS_AGENT_SOCKET_PATH = "/opt/tmp/sock/.unix_sock_agent_1234567890.sock"
+DPS_AGENT_USER_ENV = "INFSEC_SEC_USER"
+DPS_AGENT_PSM_ENV = "INFSEC_SEC_PSM"
+DPS_AGENT_ENABLE_ENV = "GET_SEC_TOKEN_STRING_FROM_DAEMON"
+
+DPS_DEFAULT_TIMEOUT_SECONDS = 1
+
+DAEMON_UPDATE_INTERVAL = 2 * 60 * 60
+
+TOKEN_SOURCE_STRING = "sec_token_string"
+TOKEN_SOURCE_PATH = "sec_token_path"
+TOKEN_SOURCE_DPS = "dps_agent"
+TOKEN_SOURCE_ZTI = "zti_agent"
+
+# Used to determine whether to fallback zti-agent
+FALLBACK_ZTI_AGENT_ENV = "FALLBACK_ZTI_AGENT"
+
+
+def singleton(cls, *args, **kw):
+    instances = {}
+
+    def _singleton(*args, **kw):
+        if cls not in instances:
+            instances[cls] = cls(*args, **kw)
+        # Allows instance variables to be modified by instantiation
+        instances[cls].__dict__.update(kw)
+        return instances[cls]
+
+    return _singleton
+
+
+def decode_jwt_svid(token_str):
+    try:
+        claim = jwt.decode(
+            token_str,
+            options={
+                "verify_signature": False,
+                "verify_aud": False,
+                "verify_exp": False,
+            },
+        )
+    except Exception as e:
+        raise ZtiJwtError(e)
+
+    zti = ZeroTrustIdentity().map2identity(claim)
+    return zti
+
+
+def decode_gdpr_or_jwt_svid(token_str):
+    if is_token_zti(token_str):
+        zti = decode_jwt_svid(token_str)
+        return zti.get_legacy_identity_from_zti()
+    else:
+        return __decode_gdpr(token_str)
+
+
+def is_token_zti(token_str):
+    try:
+        header = jwt.get_unverified_header(token_str)
+    except Exception as e:
+        return False
+    kid = "kid"
+    if kid in header:
+        return True
+    return False
+
+
+# Trim token string to remove special characters
+def _trim_token(token_str):
+    if token_str is None:
+        return None
+
+    if six.PY3:
+        return "".join(
+            [
+                char
+                for char in token_str
+                if char not in ["\r", "\n", "\t", " ", '"', "'"]
+            ]
+        )
+
+    return "".join(
+        [filter(lambda char: char not in ["\r", "\n", "\t", " ", '"', "'"], token_str)]
+    )
+
+
+def __decode_gdpr(token_str):
+    try:
+        claims = jwt.decode(
+            token_str, verify=False, options={"verify_signature": False}
+        )
+    except Exception as e:
+        raise ZtiJwtError(e)
+    return LegacyIdentity(**claims)
+
+
+@singleton
+class ZTIJwtHelper(object):
+
+    def __init__(self, update_interval_secs=180):
+        self.lock = RWLock()
+        self.thread_lock = threading.Lock()
+
+        # Global JWT SVID Token
+        self._global_token = None
+
+        self._token_path = None
+        self._token_string = None
+        self._jwt_client = None
+        self._agent_socket_path = None
+        self._last_update_time = 0
+        self.update_interval_secs = update_interval_secs
+
+        # backward compatible with dps agent: need to deprecate in future version
+        self.dps_agent_enabled = False
+        self.dps_agent_infsec_psm = None
+        self.dps_agent_infsec_user = None
+
+        self._service_identity = None
+        self._token_source = None
+
+        self._memfd = Memfd()
+
+        self._poll_every()
+
+    def __del__(self):
+        try:
+            self._memfd.unwrap_memfd()
+            self.daemon_thread.cancel()
+        except Exception:
+            pass
+        finally:
+            _LOGGER.info("ZTIJwtHelper is deleted")
+
+    def _run_refresh_once(self):
+        self._fresh()
+        threading.Timer(DAEMON_UPDATE_INTERVAL, self._run_refresh_once).start()
+
+    def _poll_every(self):
+        self.daemon_thread = threading.Timer(
+            DAEMON_UPDATE_INTERVAL, self._run_refresh_once
+        )
+        self.daemon_thread.daemon = True
+        self.daemon_thread.start()
+
+    def get_jwt_svid(self):
+        now = time.time()
+        if now - self._last_update_time > self.update_interval_secs:
+            self._fresh()
+
+        return self._get_token()
+
+    def _refresh_agent_socket_path(self):
+        agent_socket_path = os.getenv(ZTI_AGENT_SOCKET_PATH, None)
+        if (
+            agent_socket_path
+            and os.path.exists(agent_socket_path)
+            and os.stat(agent_socket_path).st_mode & stat.S_IFSOCK != 0
+        ):
+            if agent_socket_path != self._agent_socket_path:
+                self._set_agent_socket_path(agent_socket_path)
+                return
+        for path in DEFAULT_AGENT_SOCKET_PATH:
+            if os.path.exists(path) and os.stat(path).st_mode & stat.S_IFSOCK != 0:
+                if path != self._agent_socket_path:
+                    self._set_agent_socket_path(path)
+                    return
+
+    def _set_agent_socket_path(self, path):
+        try:
+            self.lock.lock()
+            _LOGGER.info("ZTI agent socket path is set to %s", path)
+            self._agent_socket_path = path
+            self._fresh_jwt_client()
+        finally:
+            self.lock.un_lock()
+
+    def get_token_string(self):
+        try:
+            self.lock.r_lock()
+            return (
+                self._token_string
+                if self._token_string
+                else os.getenv(SEC_TOKEN_STRING, None)
+            )
+        finally:
+            self.lock.r_un_lock()
+
+    def set_token_string(self, token):
+        try:
+            self.lock.lock()
+            self._token_string = token
+        finally:
+            self.lock.un_lock()
+
+    def get_token_path(self):
+        try:
+            self.lock.r_lock()
+            return (
+                self._token_path
+                if self._token_path
+                else os.getenv(SEC_TOKEN_PATH, None)
+            )
+        finally:
+            self.lock.r_un_lock()
+
+    def set_token_path(self, path):
+        try:
+            self.lock.lock()
+            self._token_path = path
+        finally:
+            self.lock.un_lock()
+
+    def set_service_identity(self, service_identity):
+        try:
+            self.lock.lock()
+            self._service_identity = service_identity
+        finally:
+            self.lock.un_lock()
+
+    def get_service_identity(self):
+        try:
+            self.lock.r_lock()
+            return self._service_identity
+        finally:
+            self.lock.r_un_lock()
+
+    def get_token_source(self):
+        try:
+            self.lock.r_lock()
+            return self._token_source
+        finally:
+            self.lock.r_un_lock()
+
+    def _fresh_env(self):
+        self._token_string = self.get_token_string()
+        self._token_path = self.get_token_path()
+
+        # backward compatible with dps agent: need to deprecate in future version
+        self.dps_agent_enabled = os.getenv(DPS_AGENT_ENABLE_ENV, None) == "1"
+        self.dps_agent_infsec_psm = os.getenv(DPS_AGENT_PSM_ENV, "")
+        self.dps_agent_infsec_user = os.getenv(DPS_AGENT_USER_ENV, "")
+
+    def _fresh_jwt_client(self):
+        config = JWTClientConfig(socket_addr="unix://" + self._agent_socket_path)
+        self._jwt_client = JWTClient(config)
+
+    def _fresh(self):
+        try:
+            self.thread_lock.acquire()
+            # dynamically update the token_path value
+            self._fresh_env()
+            fall_back_agent = False
+            token = None
+            if self._token_string:
+                self._token_source = TOKEN_SOURCE_STRING
+                token = self._token_string
+                metrics_client.count(metric_name=GET_TOKEN_FROM_STRING)
+            elif self.dps_agent_enabled and (
+                self.dps_agent_infsec_psm or self.dps_agent_infsec_user
+            ):
+                token = self._get_from_dps_agent()
+                self._token_source = TOKEN_SOURCE_DPS
+                metrics_client.count(metric_name=GET_TOKEN_FROM_DPS_AGENT_SUCCEED)
+            elif self._token_path:
+                token, fall_back_agent = self._get_from_file()
+                self._token_source = TOKEN_SOURCE_PATH
+
+            if not token or fall_back_agent:
+                self._refresh_agent_socket_path()
+                if self._agent_socket_path is not None:
+                    token = self._get_from_agent()
+                    self._token_source = TOKEN_SOURCE_ZTI
+
+            if token:
+                self._set_token(token)
+                self._refresh_identity(token)
+        except Exception as ex:
+            metrics_client.count(metric_name=GET_TOKEN_FAILED)
+            _LOGGER.warning("fresh failed, ex is %s" % ex)
+        finally:
+            self.thread_lock.release()
+
+    def _get_from_file(self):
+        try:
+            self.lock.r_lock()
+            # check if token file exists
+            if not os.path.exists(self._token_path):
+                metrics_client.count(metric_name=FETCH_TOKEN_FROM_PATH_FAILED)
+                if self._enable_fall_back():
+                    return ("", True)
+                raise IOError("token file %s not exist" % self._token_path)
+
+            # check if token file is readable
+            if not os.access(self._token_path, os.R_OK):
+                metrics_client.count(metric_name=FETCH_TOKEN_FROM_PATH_FAILED)
+                if self._enable_fall_back():
+                    return ("", True)
+                raise IOError("token file %s not readable" % self._token_path)
+
+            with open(self._token_path) as f:
+                data = f.read()
+                token_string = data.strip()
+
+            return (
+                (token_string, False)
+                if not self._enable_fall_back(token_string)
+                else ("", True)
+            )
+
+        finally:
+            self.lock.r_un_lock()
+
+    def _get_from_agent(self):
+        try:
+            serviceIdentity = self.get_service_identity() or bytedenv.get_psm()
+            jwt_resp = self._jwt_client.fetch_jwt_svid()
+            # we assume one workload should only have one identity
+            for ids in jwt_resp.svids:
+                # Parse the identity from the JWT SVID
+                if (
+                    serviceIdentity == bytedenv.service.PSM_UNKNOWN
+                    or serviceIdentity
+                    == ZeroTrustIdentity()
+                    .map2identity(
+                        jwt.decode(
+                            ids.svid,
+                            options={
+                                "verify_signature": False,
+                                "verify_aud": False,
+                                "verify_exp": False,
+                            },
+                        )
+                    )
+                    .id
+                ):
+                    return ids.svid
+            return jwt_resp.svids[0].svid if len(jwt_resp.svids) > 0 else None
+        except Exception as e:
+            metrics_client.count(metric_name=GET_TOKEN_FROM_AGENT_FAIL)
+            _LOGGER.error("fail to fetch token from workload api with err: %s" % e)
+
+    @deprecated(
+        reason="backward compatible with dps agent: need to deprecate in future version"
+    )
+    def _get_from_dps_agent(self):
+        if not json_lib:
+            _LOGGER.error("none json lib is not installed, please install it")
+            return
+        sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        sock.settimeout(DPS_DEFAULT_TIMEOUT_SECONDS)
+        try:
+            sock.connect(DPS_AGENT_SOCKET_PATH)
+        except socket.error:
+            metrics_client.count(metric_name=GET_TOKEN_FROM_DPS_AGENT_FAIL)
+            raise ZtiJwtError("fail to connect to unix domain socket!")
+
+        req = json.dumps(
+            {
+                "cmd": 1,
+                "psm": self.dps_agent_infsec_psm,
+                "user": self.dps_agent_infsec_user,
+            }
+        )
+        try:
+            sock.sendall(req.encode("utf-8") + b"\n")
+            data = sock.recv(2048)
+            data = data.decode("utf-8")
+            return data.split("\n")[0]
+
+        except Exception as ex:
+            metrics_client.count(metric_name=GET_TOKEN_FROM_DPS_AGENT_FAIL)
+            raise ZtiJwtError("get from agent failed, ex is %s", ex)
+        finally:
+            sock.close()
+
+    def _set_token(self, token_str):
+        try:
+            self.lock.lock()
+            # Trim JWT Token by removing the special characters
+            self._global_token = _trim_token(token_str)
+            self._last_update_time = time.time()
+        finally:
+            self.lock.un_lock()
+
+    def _get_token(self):
+        try:
+            self.lock.r_lock()
+            token_str = self._global_token
+            (
+                metrics_client.count(metric_name=GET_TOKEN_FAILED)
+                if not token_str
+                else metrics_client.count(metric_name=GET_TOKEN_SUCCEED)
+            )
+
+        finally:
+            self.lock.r_un_lock()
+
+        return token_str
+
+    def _refresh_identity(self, token):
+        try:
+            self.lock.r_lock()
+            self._memfd.write_content_to_memfd(
+                json.dumps(
+                    SyncInformation(token, token_source=self._token_source).to_json()
+                ).encode("utf-8")
+            )
+        except Exception as ex:
+            _LOGGER.error("refresh identity failed, ex is %s", ex)
+        finally:
+            self.lock.r_un_lock()
+
+    def _enable_fall_back(self, context=None):
+        if not context:
+            return False
+
+        if context != FALLBACK_ZTI_AGENT_ENV:
+            try:
+                jwt.decode(context, verify=False, options={"verify_signature": False})
+                return False
+            except:
+                return os.getenv(FALLBACK_ZTI_AGENT_ENV, "false") == "1"
+        return True
+
+
+jwt_helper = ZTIJwtHelper()

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/__init__.py

@@ -0,0 +1 @@
+from .error import SpiffeError

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/__version__.py

@@ -0,0 +1,3 @@
+VERSION = (0, 0, 17)
+
+__version__ = ".".join(map(str, VERSION))

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/error.py

@@ -0,0 +1,2 @@
+class SpiffeError(Exception):
+    pass

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/proto/workload/__init__.py

@@ -0,0 +1,2 @@
+from .workload_pb2 import *
+from .workload_pb2_grpc import SpiffeWorkloadAPIStub

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/proto/workload/workload_pb2.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: workload.proto
+# Protobuf Python Version: 4.25.1
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+from google.protobuf.internal import builder as _builder
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0eworkload.proto\x1a\x1cgoogle/protobuf/struct.proto\"\x11\n\x0fX509SVIDRequest\"\xb6\x01\n\x10X509SVIDResponse\x12\x18\n\x05svids\x18\x01 \x03(\x0b\x32\t.X509SVID\x12\x0b\n\x03\x63rl\x18\x02 \x03(\x0c\x12\x42\n\x11\x66\x65\x64\x65rated_bundles\x18\x03 \x03(\x0b\x32\'.X509SVIDResponse.FederatedBundlesEntry\x1a\x37\n\x15\x46\x65\x64\x65ratedBundlesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"W\n\x08X509SVID\x12\x11\n\tspiffe_id\x18\x01 \x01(\t\x12\x11\n\tx509_svid\x18\x02 \x01(\x0c\x12\x15\n\rx509_svid_key\x18\x03 \x01(\x0c\x12\x0e\n\x06\x62undle\x18\x04 \x01(\x0c\"\x14\n\x12X509BundlesRequest\"y\n\x13X509BundlesResponse\x12\x32\n\x07\x62undles\x18\x01 \x03(\x0b\x32!.X509BundlesResponse.BundlesEntry\x1a.\n\x0c\x42undlesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"*\n\x07JWTSVID\x12\x11\n\tspiffe_id\x18\x01 \x01(\t\x12\x0c\n\x04svid\x18\x02 \x01(\t\"5\n\x0eJWTSVIDRequest\x12\x10\n\x08\x61udience\x18\x01 \x03(\t\x12\x11\n\tspiffe_id\x18\x02 \x01(\t\"*\n\x0fJWTSVIDResponse\x12\x17\n\x05svids\x18\x01 \x03(\x0b\x32\x08.JWTSVID\"\x13\n\x11JWTBundlesRequest\"w\n\x12JWTBundlesResponse\x12\x31\n\x07\x62undles\x18\x01 \x03(\x0b\x32 .JWTBundlesResponse.BundlesEntry\x1a.\n\x0c\x42undlesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\x32\xfd\x01\n\x11SpiffeWorkloadAPI\x12\x36\n\rFetchX509SVID\x12\x10.X509SVIDRequest\x1a\x11.X509SVIDResponse0\x01\x12?\n\x10\x46\x65tchX509Bundles\x12\x13.X509BundlesRequest\x1a\x14.X509BundlesResponse0\x01\x12\x31\n\x0c\x46\x65tchJWTSVID\x12\x0f.JWTSVIDRequest\x1a\x10.JWTSVIDResponse\x12<\n\x0f\x46\x65tchJWTBundles\x12\x12.JWTBundlesRequest\x1a\x13.JWTBundlesResponse0\x01\x62\x06proto3')
+
+_globals = globals()
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'workload_pb2', _globals)
+if _descriptor._USE_C_DESCRIPTORS == False:
+  DESCRIPTOR._options = None
+  _globals['_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY']._options = None
+  _globals['_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY']._serialized_options = b'8\001'
+  _globals['_X509BUNDLESRESPONSE_BUNDLESENTRY']._options = None
+  _globals['_X509BUNDLESRESPONSE_BUNDLESENTRY']._serialized_options = b'8\001'
+  _globals['_JWTBUNDLESRESPONSE_BUNDLESENTRY']._options = None
+  _globals['_JWTBUNDLESRESPONSE_BUNDLESENTRY']._serialized_options = b'8\001'
+  _globals['_X509SVIDREQUEST']._serialized_start=48
+  _globals['_X509SVIDREQUEST']._serialized_end=65
+  _globals['_X509SVIDRESPONSE']._serialized_start=68
+  _globals['_X509SVIDRESPONSE']._serialized_end=250
+  _globals['_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY']._serialized_start=195
+  _globals['_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY']._serialized_end=250
+  _globals['_X509SVID']._serialized_start=252
+  _globals['_X509SVID']._serialized_end=339
+  _globals['_X509BUNDLESREQUEST']._serialized_start=341
+  _globals['_X509BUNDLESREQUEST']._serialized_end=361
+  _globals['_X509BUNDLESRESPONSE']._serialized_start=363
+  _globals['_X509BUNDLESRESPONSE']._serialized_end=484
+  _globals['_X509BUNDLESRESPONSE_BUNDLESENTRY']._serialized_start=438
+  _globals['_X509BUNDLESRESPONSE_BUNDLESENTRY']._serialized_end=484
+  _globals['_JWTSVID']._serialized_start=486
+  _globals['_JWTSVID']._serialized_end=528
+  _globals['_JWTSVIDREQUEST']._serialized_start=530
+  _globals['_JWTSVIDREQUEST']._serialized_end=583
+  _globals['_JWTSVIDRESPONSE']._serialized_start=585
+  _globals['_JWTSVIDRESPONSE']._serialized_end=627
+  _globals['_JWTBUNDLESREQUEST']._serialized_start=629
+  _globals['_JWTBUNDLESREQUEST']._serialized_end=648
+  _globals['_JWTBUNDLESRESPONSE']._serialized_start=650
+  _globals['_JWTBUNDLESRESPONSE']._serialized_end=769
+  _globals['_JWTBUNDLESRESPONSE_BUNDLESENTRY']._serialized_start=438
+  _globals['_JWTBUNDLESRESPONSE_BUNDLESENTRY']._serialized_end=484
+  _globals['_SPIFFEWORKLOADAPI']._serialized_start=772
+  _globals['_SPIFFEWORKLOADAPI']._serialized_end=1025
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/proto/workload/workload_pb2_grpc.py

@@ -0,0 +1,170 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from . import workload_pb2 as workload__pb2
+
+
+class SpiffeWorkloadAPIStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.FetchX509SVID = channel.unary_stream(
+                '/SpiffeWorkloadAPI/FetchX509SVID',
+                request_serializer=workload__pb2.X509SVIDRequest.SerializeToString,
+                response_deserializer=workload__pb2.X509SVIDResponse.FromString,
+                )
+        self.FetchX509Bundles = channel.unary_stream(
+                '/SpiffeWorkloadAPI/FetchX509Bundles',
+                request_serializer=workload__pb2.X509BundlesRequest.SerializeToString,
+                response_deserializer=workload__pb2.X509BundlesResponse.FromString,
+                )
+        self.FetchJWTSVID = channel.unary_unary(
+                '/SpiffeWorkloadAPI/FetchJWTSVID',
+                request_serializer=workload__pb2.JWTSVIDRequest.SerializeToString,
+                response_deserializer=workload__pb2.JWTSVIDResponse.FromString,
+                )
+        self.FetchJWTBundles = channel.unary_stream(
+                '/SpiffeWorkloadAPI/FetchJWTBundles',
+                request_serializer=workload__pb2.JWTBundlesRequest.SerializeToString,
+                response_deserializer=workload__pb2.JWTBundlesResponse.FromString,
+                )
+
+
+class SpiffeWorkloadAPIServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def FetchX509SVID(self, request, context):
+        """X.509-SVID Profile
+        Fetch all SPIFFE identities the workload is entitled to, as
+        well as related information like trust bundles and CRLs. As
+        this information changes, subsequent messages will be sent.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def FetchX509Bundles(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def FetchJWTSVID(self, request, context):
+        """JWT-SVID Profile
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def FetchJWTBundles(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_SpiffeWorkloadAPIServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'FetchX509SVID': grpc.unary_stream_rpc_method_handler(
+                    servicer.FetchX509SVID,
+                    request_deserializer=workload__pb2.X509SVIDRequest.FromString,
+                    response_serializer=workload__pb2.X509SVIDResponse.SerializeToString,
+            ),
+            'FetchX509Bundles': grpc.unary_stream_rpc_method_handler(
+                    servicer.FetchX509Bundles,
+                    request_deserializer=workload__pb2.X509BundlesRequest.FromString,
+                    response_serializer=workload__pb2.X509BundlesResponse.SerializeToString,
+            ),
+            'FetchJWTSVID': grpc.unary_unary_rpc_method_handler(
+                    servicer.FetchJWTSVID,
+                    request_deserializer=workload__pb2.JWTSVIDRequest.FromString,
+                    response_serializer=workload__pb2.JWTSVIDResponse.SerializeToString,
+            ),
+            'FetchJWTBundles': grpc.unary_stream_rpc_method_handler(
+                    servicer.FetchJWTBundles,
+                    request_deserializer=workload__pb2.JWTBundlesRequest.FromString,
+                    response_serializer=workload__pb2.JWTBundlesResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'SpiffeWorkloadAPI', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class SpiffeWorkloadAPI(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def FetchX509SVID(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(request, target, '/SpiffeWorkloadAPI/FetchX509SVID',
+            workload__pb2.X509SVIDRequest.SerializeToString,
+            workload__pb2.X509SVIDResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def FetchX509Bundles(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(request, target, '/SpiffeWorkloadAPI/FetchX509Bundles',
+            workload__pb2.X509BundlesRequest.SerializeToString,
+            workload__pb2.X509BundlesResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def FetchJWTSVID(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/SpiffeWorkloadAPI/FetchJWTSVID',
+            workload__pb2.JWTSVIDRequest.SerializeToString,
+            workload__pb2.JWTSVIDResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def FetchJWTBundles(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(request, target, '/SpiffeWorkloadAPI/FetchJWTBundles',
+            workload__pb2.JWTBundlesRequest.SerializeToString,
+            workload__pb2.JWTBundlesResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/proto/workload_py2/__init__.py

@@ -0,0 +1,2 @@
+from .workload_pb2 import *
+from .workload_pb2_grpc import SpiffeWorkloadAPIStub

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/proto/workload_py2/workload_pb2.py

@@ -0,0 +1,665 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: workload.proto
+"""Generated protocol buffer code."""
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from google.protobuf import reflection as _reflection
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+from google.protobuf import struct_pb2 as google_dot_protobuf_dot_struct__pb2
+
+
+DESCRIPTOR = _descriptor.FileDescriptor(
+  name='workload.proto',
+  package='',
+  syntax='proto3',
+  serialized_options=None,
+  create_key=_descriptor._internal_create_key,
+  serialized_pb=b'\n\x0eworkload.proto\x1a\x1cgoogle/protobuf/struct.proto\"\x11\n\x0fX509SVIDRequest\"\xb6\x01\n\x10X509SVIDResponse\x12\x18\n\x05svids\x18\x01 \x03(\x0b\x32\t.X509SVID\x12\x0b\n\x03\x63rl\x18\x02 \x03(\x0c\x12\x42\n\x11\x66\x65\x64\x65rated_bundles\x18\x03 \x03(\x0b\x32\'.X509SVIDResponse.FederatedBundlesEntry\x1a\x37\n\x15\x46\x65\x64\x65ratedBundlesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"W\n\x08X509SVID\x12\x11\n\tspiffe_id\x18\x01 \x01(\t\x12\x11\n\tx509_svid\x18\x02 \x01(\x0c\x12\x15\n\rx509_svid_key\x18\x03 \x01(\x0c\x12\x0e\n\x06\x62undle\x18\x04 \x01(\x0c\"\x14\n\x12X509BundlesRequest\"y\n\x13X509BundlesResponse\x12\x32\n\x07\x62undles\x18\x01 \x03(\x0b\x32!.X509BundlesResponse.BundlesEntry\x1a.\n\x0c\x42undlesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\"*\n\x07JWTSVID\x12\x11\n\tspiffe_id\x18\x01 \x01(\t\x12\x0c\n\x04svid\x18\x02 \x01(\t\"5\n\x0eJWTSVIDRequest\x12\x10\n\x08\x61udience\x18\x01 \x03(\t\x12\x11\n\tspiffe_id\x18\x02 \x01(\t\"*\n\x0fJWTSVIDResponse\x12\x17\n\x05svids\x18\x01 \x03(\x0b\x32\x08.JWTSVID\"\x13\n\x11JWTBundlesRequest\"w\n\x12JWTBundlesResponse\x12\x31\n\x07\x62undles\x18\x01 \x03(\x0b\x32 .JWTBundlesResponse.BundlesEntry\x1a.\n\x0c\x42undlesEntry\x12\x0b\n\x03key\x18\x01 \x01(\t\x12\r\n\x05value\x18\x02 \x01(\x0c:\x02\x38\x01\x32\xfd\x01\n\x11SpiffeWorkloadAPI\x12\x36\n\rFetchX509SVID\x12\x10.X509SVIDRequest\x1a\x11.X509SVIDResponse0\x01\x12?\n\x10\x46\x65tchX509Bundles\x12\x13.X509BundlesRequest\x1a\x14.X509BundlesResponse0\x01\x12\x31\n\x0c\x46\x65tchJWTSVID\x12\x0f.JWTSVIDRequest\x1a\x10.JWTSVIDResponse\x12<\n\x0f\x46\x65tchJWTBundles\x12\x12.JWTBundlesRequest\x1a\x13.JWTBundlesResponse0\x01\x62\x06proto3'
+  ,
+  dependencies=[google_dot_protobuf_dot_struct__pb2.DESCRIPTOR,])
+
+
+
+
+_X509SVIDREQUEST = _descriptor.Descriptor(
+  name='X509SVIDRequest',
+  full_name='X509SVIDRequest',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=48,
+  serialized_end=65,
+)
+
+
+_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY = _descriptor.Descriptor(
+  name='FederatedBundlesEntry',
+  full_name='X509SVIDResponse.FederatedBundlesEntry',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='key', full_name='X509SVIDResponse.FederatedBundlesEntry.key', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='value', full_name='X509SVIDResponse.FederatedBundlesEntry.value', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=b'8\001',
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=195,
+  serialized_end=250,
+)
+
+_X509SVIDRESPONSE = _descriptor.Descriptor(
+  name='X509SVIDResponse',
+  full_name='X509SVIDResponse',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='svids', full_name='X509SVIDResponse.svids', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='crl', full_name='X509SVIDResponse.crl', index=1,
+      number=2, type=12, cpp_type=9, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='federated_bundles', full_name='X509SVIDResponse.federated_bundles', index=2,
+      number=3, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY, ],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=68,
+  serialized_end=250,
+)
+
+
+_X509SVID = _descriptor.Descriptor(
+  name='X509SVID',
+  full_name='X509SVID',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='spiffe_id', full_name='X509SVID.spiffe_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='x509_svid', full_name='X509SVID.x509_svid', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='x509_svid_key', full_name='X509SVID.x509_svid_key', index=2,
+      number=3, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='bundle', full_name='X509SVID.bundle', index=3,
+      number=4, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=252,
+  serialized_end=339,
+)
+
+
+_X509BUNDLESREQUEST = _descriptor.Descriptor(
+  name='X509BundlesRequest',
+  full_name='X509BundlesRequest',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=341,
+  serialized_end=361,
+)
+
+
+_X509BUNDLESRESPONSE_BUNDLESENTRY = _descriptor.Descriptor(
+  name='BundlesEntry',
+  full_name='X509BundlesResponse.BundlesEntry',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='key', full_name='X509BundlesResponse.BundlesEntry.key', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='value', full_name='X509BundlesResponse.BundlesEntry.value', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=b'8\001',
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=438,
+  serialized_end=484,
+)
+
+_X509BUNDLESRESPONSE = _descriptor.Descriptor(
+  name='X509BundlesResponse',
+  full_name='X509BundlesResponse',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='bundles', full_name='X509BundlesResponse.bundles', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[_X509BUNDLESRESPONSE_BUNDLESENTRY, ],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=363,
+  serialized_end=484,
+)
+
+
+_JWTSVID = _descriptor.Descriptor(
+  name='JWTSVID',
+  full_name='JWTSVID',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='spiffe_id', full_name='JWTSVID.spiffe_id', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='svid', full_name='JWTSVID.svid', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=486,
+  serialized_end=528,
+)
+
+
+_JWTSVIDREQUEST = _descriptor.Descriptor(
+  name='JWTSVIDRequest',
+  full_name='JWTSVIDRequest',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='audience', full_name='JWTSVIDRequest.audience', index=0,
+      number=1, type=9, cpp_type=9, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='spiffe_id', full_name='JWTSVIDRequest.spiffe_id', index=1,
+      number=2, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=530,
+  serialized_end=583,
+)
+
+
+_JWTSVIDRESPONSE = _descriptor.Descriptor(
+  name='JWTSVIDResponse',
+  full_name='JWTSVIDResponse',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='svids', full_name='JWTSVIDResponse.svids', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=585,
+  serialized_end=627,
+)
+
+
+_JWTBUNDLESREQUEST = _descriptor.Descriptor(
+  name='JWTBundlesRequest',
+  full_name='JWTBundlesRequest',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=629,
+  serialized_end=648,
+)
+
+
+_JWTBUNDLESRESPONSE_BUNDLESENTRY = _descriptor.Descriptor(
+  name='BundlesEntry',
+  full_name='JWTBundlesResponse.BundlesEntry',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='key', full_name='JWTBundlesResponse.BundlesEntry.key', index=0,
+      number=1, type=9, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"".decode('utf-8'),
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+    _descriptor.FieldDescriptor(
+      name='value', full_name='JWTBundlesResponse.BundlesEntry.value', index=1,
+      number=2, type=12, cpp_type=9, label=1,
+      has_default_value=False, default_value=b"",
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[],
+  enum_types=[
+  ],
+  serialized_options=b'8\001',
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=438,
+  serialized_end=484,
+)
+
+_JWTBUNDLESRESPONSE = _descriptor.Descriptor(
+  name='JWTBundlesResponse',
+  full_name='JWTBundlesResponse',
+  filename=None,
+  file=DESCRIPTOR,
+  containing_type=None,
+  create_key=_descriptor._internal_create_key,
+  fields=[
+    _descriptor.FieldDescriptor(
+      name='bundles', full_name='JWTBundlesResponse.bundles', index=0,
+      number=1, type=11, cpp_type=10, label=3,
+      has_default_value=False, default_value=[],
+      message_type=None, enum_type=None, containing_type=None,
+      is_extension=False, extension_scope=None,
+      serialized_options=None, file=DESCRIPTOR,  create_key=_descriptor._internal_create_key),
+  ],
+  extensions=[
+  ],
+  nested_types=[_JWTBUNDLESRESPONSE_BUNDLESENTRY, ],
+  enum_types=[
+  ],
+  serialized_options=None,
+  is_extendable=False,
+  syntax='proto3',
+  extension_ranges=[],
+  oneofs=[
+  ],
+  serialized_start=650,
+  serialized_end=769,
+)
+
+_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY.containing_type = _X509SVIDRESPONSE
+_X509SVIDRESPONSE.fields_by_name['svids'].message_type = _X509SVID
+_X509SVIDRESPONSE.fields_by_name['federated_bundles'].message_type = _X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY
+_X509BUNDLESRESPONSE_BUNDLESENTRY.containing_type = _X509BUNDLESRESPONSE
+_X509BUNDLESRESPONSE.fields_by_name['bundles'].message_type = _X509BUNDLESRESPONSE_BUNDLESENTRY
+_JWTSVIDRESPONSE.fields_by_name['svids'].message_type = _JWTSVID
+_JWTBUNDLESRESPONSE_BUNDLESENTRY.containing_type = _JWTBUNDLESRESPONSE
+_JWTBUNDLESRESPONSE.fields_by_name['bundles'].message_type = _JWTBUNDLESRESPONSE_BUNDLESENTRY
+DESCRIPTOR.message_types_by_name['X509SVIDRequest'] = _X509SVIDREQUEST
+DESCRIPTOR.message_types_by_name['X509SVIDResponse'] = _X509SVIDRESPONSE
+DESCRIPTOR.message_types_by_name['X509SVID'] = _X509SVID
+DESCRIPTOR.message_types_by_name['X509BundlesRequest'] = _X509BUNDLESREQUEST
+DESCRIPTOR.message_types_by_name['X509BundlesResponse'] = _X509BUNDLESRESPONSE
+DESCRIPTOR.message_types_by_name['JWTSVID'] = _JWTSVID
+DESCRIPTOR.message_types_by_name['JWTSVIDRequest'] = _JWTSVIDREQUEST
+DESCRIPTOR.message_types_by_name['JWTSVIDResponse'] = _JWTSVIDRESPONSE
+DESCRIPTOR.message_types_by_name['JWTBundlesRequest'] = _JWTBUNDLESREQUEST
+DESCRIPTOR.message_types_by_name['JWTBundlesResponse'] = _JWTBUNDLESRESPONSE
+_sym_db.RegisterFileDescriptor(DESCRIPTOR)
+
+X509SVIDRequest = _reflection.GeneratedProtocolMessageType('X509SVIDRequest', (_message.Message,), {
+  'DESCRIPTOR' : _X509SVIDREQUEST,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:X509SVIDRequest)
+  })
+_sym_db.RegisterMessage(X509SVIDRequest)
+
+X509SVIDResponse = _reflection.GeneratedProtocolMessageType('X509SVIDResponse', (_message.Message,), {
+
+  'FederatedBundlesEntry' : _reflection.GeneratedProtocolMessageType('FederatedBundlesEntry', (_message.Message,), {
+    'DESCRIPTOR' : _X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY,
+    '__module__' : 'workload_pb2'
+    # @@protoc_insertion_point(class_scope:X509SVIDResponse.FederatedBundlesEntry)
+    })
+  ,
+  'DESCRIPTOR' : _X509SVIDRESPONSE,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:X509SVIDResponse)
+  })
+_sym_db.RegisterMessage(X509SVIDResponse)
+_sym_db.RegisterMessage(X509SVIDResponse.FederatedBundlesEntry)
+
+X509SVID = _reflection.GeneratedProtocolMessageType('X509SVID', (_message.Message,), {
+  'DESCRIPTOR' : _X509SVID,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:X509SVID)
+  })
+_sym_db.RegisterMessage(X509SVID)
+
+X509BundlesRequest = _reflection.GeneratedProtocolMessageType('X509BundlesRequest', (_message.Message,), {
+  'DESCRIPTOR' : _X509BUNDLESREQUEST,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:X509BundlesRequest)
+  })
+_sym_db.RegisterMessage(X509BundlesRequest)
+
+X509BundlesResponse = _reflection.GeneratedProtocolMessageType('X509BundlesResponse', (_message.Message,), {
+
+  'BundlesEntry' : _reflection.GeneratedProtocolMessageType('BundlesEntry', (_message.Message,), {
+    'DESCRIPTOR' : _X509BUNDLESRESPONSE_BUNDLESENTRY,
+    '__module__' : 'workload_pb2'
+    # @@protoc_insertion_point(class_scope:X509BundlesResponse.BundlesEntry)
+    })
+  ,
+  'DESCRIPTOR' : _X509BUNDLESRESPONSE,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:X509BundlesResponse)
+  })
+_sym_db.RegisterMessage(X509BundlesResponse)
+_sym_db.RegisterMessage(X509BundlesResponse.BundlesEntry)
+
+JWTSVID = _reflection.GeneratedProtocolMessageType('JWTSVID', (_message.Message,), {
+  'DESCRIPTOR' : _JWTSVID,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:JWTSVID)
+  })
+_sym_db.RegisterMessage(JWTSVID)
+
+JWTSVIDRequest = _reflection.GeneratedProtocolMessageType('JWTSVIDRequest', (_message.Message,), {
+  'DESCRIPTOR' : _JWTSVIDREQUEST,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:JWTSVIDRequest)
+  })
+_sym_db.RegisterMessage(JWTSVIDRequest)
+
+JWTSVIDResponse = _reflection.GeneratedProtocolMessageType('JWTSVIDResponse', (_message.Message,), {
+  'DESCRIPTOR' : _JWTSVIDRESPONSE,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:JWTSVIDResponse)
+  })
+_sym_db.RegisterMessage(JWTSVIDResponse)
+
+JWTBundlesRequest = _reflection.GeneratedProtocolMessageType('JWTBundlesRequest', (_message.Message,), {
+  'DESCRIPTOR' : _JWTBUNDLESREQUEST,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:JWTBundlesRequest)
+  })
+_sym_db.RegisterMessage(JWTBundlesRequest)
+
+JWTBundlesResponse = _reflection.GeneratedProtocolMessageType('JWTBundlesResponse', (_message.Message,), {
+
+  'BundlesEntry' : _reflection.GeneratedProtocolMessageType('BundlesEntry', (_message.Message,), {
+    'DESCRIPTOR' : _JWTBUNDLESRESPONSE_BUNDLESENTRY,
+    '__module__' : 'workload_pb2'
+    # @@protoc_insertion_point(class_scope:JWTBundlesResponse.BundlesEntry)
+    })
+  ,
+  'DESCRIPTOR' : _JWTBUNDLESRESPONSE,
+  '__module__' : 'workload_pb2'
+  # @@protoc_insertion_point(class_scope:JWTBundlesResponse)
+  })
+_sym_db.RegisterMessage(JWTBundlesResponse)
+_sym_db.RegisterMessage(JWTBundlesResponse.BundlesEntry)
+
+
+_X509SVIDRESPONSE_FEDERATEDBUNDLESENTRY._options = None
+_X509BUNDLESRESPONSE_BUNDLESENTRY._options = None
+_JWTBUNDLESRESPONSE_BUNDLESENTRY._options = None
+
+_SPIFFEWORKLOADAPI = _descriptor.ServiceDescriptor(
+  name='SpiffeWorkloadAPI',
+  full_name='SpiffeWorkloadAPI',
+  file=DESCRIPTOR,
+  index=0,
+  serialized_options=None,
+  create_key=_descriptor._internal_create_key,
+  serialized_start=772,
+  serialized_end=1025,
+  methods=[
+  _descriptor.MethodDescriptor(
+    name='FetchX509SVID',
+    full_name='SpiffeWorkloadAPI.FetchX509SVID',
+    index=0,
+    containing_service=None,
+    input_type=_X509SVIDREQUEST,
+    output_type=_X509SVIDRESPONSE,
+    serialized_options=None,
+    create_key=_descriptor._internal_create_key,
+  ),
+  _descriptor.MethodDescriptor(
+    name='FetchX509Bundles',
+    full_name='SpiffeWorkloadAPI.FetchX509Bundles',
+    index=1,
+    containing_service=None,
+    input_type=_X509BUNDLESREQUEST,
+    output_type=_X509BUNDLESRESPONSE,
+    serialized_options=None,
+    create_key=_descriptor._internal_create_key,
+  ),
+  _descriptor.MethodDescriptor(
+    name='FetchJWTSVID',
+    full_name='SpiffeWorkloadAPI.FetchJWTSVID',
+    index=2,
+    containing_service=None,
+    input_type=_JWTSVIDREQUEST,
+    output_type=_JWTSVIDRESPONSE,
+    serialized_options=None,
+    create_key=_descriptor._internal_create_key,
+  ),
+  _descriptor.MethodDescriptor(
+    name='FetchJWTBundles',
+    full_name='SpiffeWorkloadAPI.FetchJWTBundles',
+    index=3,
+    containing_service=None,
+    input_type=_JWTBUNDLESREQUEST,
+    output_type=_JWTBUNDLESRESPONSE,
+    serialized_options=None,
+    create_key=_descriptor._internal_create_key,
+  ),
+])
+_sym_db.RegisterServiceDescriptor(_SPIFFEWORKLOADAPI)
+
+DESCRIPTOR.services_by_name['SpiffeWorkloadAPI'] = _SPIFFEWORKLOADAPI
+
+# @@protoc_insertion_point(module_scope)

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/proto/workload_py2/workload_pb2_grpc.py

@@ -0,0 +1,170 @@
+# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
+"""Client and server classes corresponding to protobuf-defined services."""
+import grpc
+
+from ..workload_py2 import workload_pb2 as workload__pb2
+
+
+class SpiffeWorkloadAPIStub(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def __init__(self, channel):
+        """Constructor.
+
+        Args:
+            channel: A grpc.Channel.
+        """
+        self.FetchX509SVID = channel.unary_stream(
+                '/SpiffeWorkloadAPI/FetchX509SVID',
+                request_serializer=workload__pb2.X509SVIDRequest.SerializeToString,
+                response_deserializer=workload__pb2.X509SVIDResponse.FromString,
+                )
+        self.FetchX509Bundles = channel.unary_stream(
+                '/SpiffeWorkloadAPI/FetchX509Bundles',
+                request_serializer=workload__pb2.X509BundlesRequest.SerializeToString,
+                response_deserializer=workload__pb2.X509BundlesResponse.FromString,
+                )
+        self.FetchJWTSVID = channel.unary_unary(
+                '/SpiffeWorkloadAPI/FetchJWTSVID',
+                request_serializer=workload__pb2.JWTSVIDRequest.SerializeToString,
+                response_deserializer=workload__pb2.JWTSVIDResponse.FromString,
+                )
+        self.FetchJWTBundles = channel.unary_stream(
+                '/SpiffeWorkloadAPI/FetchJWTBundles',
+                request_serializer=workload__pb2.JWTBundlesRequest.SerializeToString,
+                response_deserializer=workload__pb2.JWTBundlesResponse.FromString,
+                )
+
+
+class SpiffeWorkloadAPIServicer(object):
+    """Missing associated documentation comment in .proto file."""
+
+    def FetchX509SVID(self, request, context):
+        """X.509-SVID Profile
+        Fetch all SPIFFE identities the workload is entitled to, as
+        well as related information like trust bundles and CRLs. As
+        this information changes, subsequent messages will be sent.
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def FetchX509Bundles(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def FetchJWTSVID(self, request, context):
+        """JWT-SVID Profile
+        """
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+    def FetchJWTBundles(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
+
+def add_SpiffeWorkloadAPIServicer_to_server(servicer, server):
+    rpc_method_handlers = {
+            'FetchX509SVID': grpc.unary_stream_rpc_method_handler(
+                    servicer.FetchX509SVID,
+                    request_deserializer=workload__pb2.X509SVIDRequest.FromString,
+                    response_serializer=workload__pb2.X509SVIDResponse.SerializeToString,
+            ),
+            'FetchX509Bundles': grpc.unary_stream_rpc_method_handler(
+                    servicer.FetchX509Bundles,
+                    request_deserializer=workload__pb2.X509BundlesRequest.FromString,
+                    response_serializer=workload__pb2.X509BundlesResponse.SerializeToString,
+            ),
+            'FetchJWTSVID': grpc.unary_unary_rpc_method_handler(
+                    servicer.FetchJWTSVID,
+                    request_deserializer=workload__pb2.JWTSVIDRequest.FromString,
+                    response_serializer=workload__pb2.JWTSVIDResponse.SerializeToString,
+            ),
+            'FetchJWTBundles': grpc.unary_stream_rpc_method_handler(
+                    servicer.FetchJWTBundles,
+                    request_deserializer=workload__pb2.JWTBundlesRequest.FromString,
+                    response_serializer=workload__pb2.JWTBundlesResponse.SerializeToString,
+            ),
+    }
+    generic_handler = grpc.method_handlers_generic_handler(
+            'SpiffeWorkloadAPI', rpc_method_handlers)
+    server.add_generic_rpc_handlers((generic_handler,))
+
+
+ # This class is part of an EXPERIMENTAL API.
+class SpiffeWorkloadAPI(object):
+    """Missing associated documentation comment in .proto file."""
+
+    @staticmethod
+    def FetchX509SVID(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(request, target, '/SpiffeWorkloadAPI/FetchX509SVID',
+            workload__pb2.X509SVIDRequest.SerializeToString,
+            workload__pb2.X509SVIDResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def FetchX509Bundles(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(request, target, '/SpiffeWorkloadAPI/FetchX509Bundles',
+            workload__pb2.X509BundlesRequest.SerializeToString,
+            workload__pb2.X509BundlesResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def FetchJWTSVID(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(request, target, '/SpiffeWorkloadAPI/FetchJWTSVID',
+            workload__pb2.JWTSVIDRequest.SerializeToString,
+            workload__pb2.JWTSVIDResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)
+
+    @staticmethod
+    def FetchJWTBundles(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_stream(request, target, '/SpiffeWorkloadAPI/FetchJWTBundles',
+            workload__pb2.JWTBundlesRequest.SerializeToString,
+            workload__pb2.JWTBundlesResponse.FromString,
+            options, channel_credentials,
+            insecure, call_credentials, compression, wait_for_ready, timeout, metadata)

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/spiffeid/__init__.py

@@ -0,0 +1 @@
+from .id import ID

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/spiffeid/id.py

@@ -0,0 +1,87 @@
+from enum import Enum
+
+from cryptography import x509
+from urllib3.util import url
+
+from ... import SpiffeError
+
+
+class ID(object):
+    def __init__(self, trust_domain=None, path=None):
+        self.trust_domain = trust_domain
+        self.path = path
+
+    def __str__(self):
+        return "{ From str method of ID: trust_domain = %s, path = %s }" % (self.trust_domain, self.path)
+
+    @classmethod
+    def from_str(cls, id_str):
+        return cls.from_uri(id_str)
+
+    @classmethod
+    def from_uri(cls, uri):
+        if not hasattr(uri, 'hostname') or not hasattr(uri, 'path'):
+            uri = url.parse_url(uri)
+        trust_domain = str(uri.hostname)
+        path = str(uri.path).lstrip('/').rstrip('/')
+        return cls(trust_domain, path)
+
+    def is_zero(self):
+        if not self.trust_domain:
+            return True
+        return False
+
+    def to_str(self):
+        if self.is_zero():
+            return ""
+        return self.trust_domain + '/' + self.path
+
+    def get_trust_domain(self):
+        return str(self.trust_domain)
+
+    def get_path(self):
+        return str(self.path)
+
+
+class IdType(Enum):
+    ANY_TYPE = 1
+    TRUST_DOMAIN_ID = 2
+    WORKLOAD_ID = 3
+
+
+class ValidationOptions:
+    def __init__(self, trust_domain='', trust_domain_required=False, id_type=IdType.ANY_TYPE):
+        self.trust_domain = trust_domain
+        self.trust_domain_required = trust_domain_required
+        self.id_type = id_type
+
+
+def validate_uri(uri, options):
+    # type: (url.Url, ValidationOptions) -> None
+    if uri is None:
+        raise SpiffeError('spiffe id is empty')
+    if not isinstance(uri, url.Url):
+        raise SpiffeError('not a uri ({type})'.format(type=type(uri)))
+    if uri.scheme.lower() != 'spiffe':
+        raise SpiffeError('invalid scheme')
+    if not uri.host:
+        raise SpiffeError('trust domain is empty')
+    if uri.port is not None:
+        raise SpiffeError('port is not allowed')
+    if uri.fragment is not None:
+        raise SpiffeError('fragment is not allowed')
+    if uri.query is not None:
+        raise SpiffeError('query is not allowed')
+
+    if options.trust_domain_required:
+        if not options.trust_domain:
+            raise SpiffeError('trust domain to validate against cannot be empty')
+        if uri.host != options.trust_domain:
+            raise SpiffeError('{id} does not belong to trust domain {td}'.format(id=uri, td=options.trust_domain))
+
+    if options.id_type == IdType.TRUST_DOMAIN_ID:
+        if uri.path:
+            raise SpiffeError('path is not empty')
+    if options.id_type == IdType.WORKLOAD_ID:
+        if not uri.path:
+            raise SpiffeError('path is empty')

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/svid/x509svid/__init__.py

@@ -0,0 +1,2 @@
+from .svid import *
+from .verify import *

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/svid/x509svid/svid.py

@@ -0,0 +1,83 @@
+from typing import List
+
+from cryptography import x509
+
+from ... import spiffeid
+from .... import SpiffeError
+
+
+class SvidError(SpiffeError):
+    pass
+
+
+def id_from_cert(cert):
+    # type: (x509.Certificate) -> spiffeid.ID
+    sans = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value
+    uris = [san for san in sans if type(san) == x509.UniformResourceIdentifier]
+    if len(uris) == 0:
+        raise SpiffeError("certificate contains no URI SAN")
+    elif len(uris) > 1:
+        raise SpiffeError("certificate contains more than one URI SAN")
+    return spiffeid.ID().from_str(uris[0].value)
+
+
+def validate_certificates(certs):
+    # type: (List[x509.Certificate]) -> spiffeid.ID
+    if len(certs) == 0:
+        raise SvidError('no certificates found')
+
+    leaf_id = validate_leaf_certificate(certs[0])
+
+    validate_signing_certificates(certs[1:])
+
+    return leaf_id
+
+
+def validate_leaf_certificate(leaf):
+    # type: (x509.Certificate) -> spiffeid.ID
+    try:
+        leaf_id = id_from_cert(leaf)
+    except Exception as e:
+        raise SvidError('cannot get leaf certificate SPIFFE ID').with_traceback(e.__traceback__)
+
+    if is_ca(leaf):
+        raise SvidError('leaf certificate must not have CA flag set to true')
+
+    validate_leaf_cert_key_usage(leaf)
+
+    return leaf_id
+
+
+def validate_signing_certificates(certs):
+    # type: (List[x509.Certificate]) -> None
+    for cert in certs:
+        if not is_ca(cert):
+            raise SvidError('signing certificate must have CA flag set to true')
+        validate_signing_cert_key_usage(cert)
+
+
+def is_ca(cert):
+    # type: (x509.Certificate) -> bool
+    basic_constraints = cert.extensions.get_extension_for_class(x509.BasicConstraints).value
+    # type: x509.BasicConstraints
+    return basic_constraints.ca
+
+
+def validate_leaf_cert_key_usage(leaf):
+    # type: (x509.Certificate) -> None
+    key_usage = leaf.extensions.get_extension_for_class(x509.KeyUsage).value
+    # type: x509.KeyUsage
+    if not key_usage.digital_signature:
+        raise SvidError('leaf certificate must have \'digital_signature\' set as key usage')
+    if key_usage.key_cert_sign:
+        raise SvidError('leaf certificate must not have \'key_cert_sign\' set as key usage')
+    if key_usage.crl_sign:
+        raise SvidError('leaf certificate must not have \'crl_sign\' set as key usage')
+
+
+def validate_signing_cert_key_usage(leaf):
+    # type: (x509.Certificate) -> None
+    key_usage = leaf.extensions.get_extension_for_class(x509.KeyUsage).value
+    # type: x509.KeyUsage
+    if not key_usage.key_cert_sign:
+        raise SvidError('signing certificate must have \'key_cert_sign\' set as key usage')

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spiffe/svid/x509svid/verify.py

@@ -0,0 +1,43 @@
+from typing import List, Dict, Tuple
+
+from OpenSSL import crypto
+from cryptography import x509
+
+
+from ...spiffeid import ID
+from .svid import validate_leaf_certificate, SvidError
+
+
+def verify(certs, bundle_source):
+	# type: (List[x509.Certificate], Dict[str, List[x509.Certificate]]) -> Tuple[ID, List[x509.Certificate]]
+	"""
+	Verifies an X.509-SVID chain using the X.509 bundle source. It returns the SPIFFE ID of the X.509-SVID and
+	one or more chains back to a root in the bundle.
+
+	:param certs: the X.509-SVID chain to verify.
+	:param bundle_source: the X.509 bundle source to verify against.
+	:return: the SPIFFE ID of the X.509-SVID and verified chains back to a root in the bundle.
+	"""
+	if len(certs) == 0:
+		raise SvidError('empty certificates chain')
+	if len(bundle_source) == 0:
+		raise SvidError('bundle source is required')
+
+	leaf_cert = certs[0]
+	leaf_id = validate_leaf_certificate(leaf_cert)
+
+	try:
+		bundle = bundle_source[leaf_id.get_trust_domain()]
+	except Exception as e:
+		raise SvidError('could not get X509 bundle: {name}'.format(name=leaf_id.get_trust_domain())).with_traceback(e.__traceback__)
+
+	store = crypto.X509Store()
+	for root in bundle:
+		store.add_cert(crypto.X509.from_cryptography(root))
+	for intermediate in certs[1:]:
+		store.add_cert(crypto.X509.from_cryptography(intermediate))
+
+	store_ctx = crypto.X509StoreContext(store, crypto.X509.from_cryptography(leaf_cert))
+	verified_chains = [cert.to_cryptography() for cert in store_ctx.get_verified_chain()]
+
+	return leaf_id, verified_chains

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spire/api/workload/__init__.py

@@ -0,0 +1,2 @@
+from .x509_client import X509ClientConfig, X509Client
+from .jwt_client import JWTClientConfig, JWTClient

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spire/api/workload/jwt_client.py

@@ -0,0 +1,49 @@
+import logging
+import grpc
+
+has_builder = False
+try:
+    from google.protobuf.internal import builder as _
+    has_builder = True
+except:
+    pass
+
+import sys
+if sys.version_info[0:2] >= (3, 5) and has_builder:
+    from ....spiffe.proto import workload
+else:
+    from ....spiffe.proto import workload_py2 as workload
+
+
+DEFAULT_AGENT_SOCKET_ADDR = "unix:///var/run/zti-agent.sock"
+DEFAULT_TIMEOUT_SECONDS = 5
+METADATA = [("workload.spiffe.io", "true")]
+
+
+class JWTClientConfig(object):
+    def __init__(self, socket_addr=DEFAULT_AGENT_SOCKET_ADDR, logger=logging):
+        self.socket_addr = socket_addr
+        self.logger = logger
+
+
+class JWTClient(object):
+    def __init__(self, config, grpc_options=None):
+        self.config = config
+        self.grpc_channel = grpc.insecure_channel(self.config.socket_addr, options=grpc_options)
+        self.stub = workload.SpiffeWorkloadAPIStub(self.grpc_channel)
+
+    def fetch_jwt_svid(self):
+        # type: () -> workload.JWTSVIDResponse
+        return self.stub.FetchJWTSVID(
+            workload.JWTSVIDRequest(audience=["zti"]),
+            metadata=METADATA,
+            timeout=DEFAULT_TIMEOUT_SECONDS,
+        )
+
+    def get_jwt_bundle(self):
+        # type: () -> workload.JWTBundlesResponse
+        return self.stub.FetchJWTBundles(
+            workload.JWTBundlesRequest(),
+            metadata=METADATA,
+            timeout=DEFAULT_TIMEOUT_SECONDS,
+        )

miniconda3/envs/ladir/lib/python3.10/site-packages/ztispiffe/spire/api/workload/x509_client.py

@@ -0,0 +1,200 @@
+try:
+    import queue
+except ImportError:
+    import Queue as queue
+
+import logging
+import threading
+import time
+from threading import Lock
+from typing import List, Optional
+import grpc
+
+from .... import SpiffeError
+
+has_builder = False
+try:
+    from google.protobuf.internal import builder as _
+    has_builder = True
+except:
+    pass
+
+import sys
+if sys.version_info[0:2] >= (3, 5) and has_builder:
+    from ....spiffe.proto import workload
+else:
+    from ....spiffe.proto import workload_py2 as workload
+
+
+class X509ClientError(SpiffeError):
+    pass
+
+
+class X509ClientConfig(object):
+    def __init__(self, addr='', fail_on_error=False, timeout=300, backoff_cap=30, logger=logging):
+        self.__backoff_min__ = 1
+
+        self.addr = addr
+        self.fail_on_error = fail_on_error
+        self.timeout = timeout
+        self.backoff_cap = backoff_cap
+        self.logger = logger
+
+
+class X509Client(object):
+    def __init__(self, config, grpc_options=None): # type: (X509ClientConfig, Optional[List[grpc.ChannelOption]]) -> None
+        self.config = config
+        # grpc options
+        self.grpc_options = grpc_options # type: Optional[List[grpc.ChannelOption]]
+        # type: queue.Queue[workload.X509SVIDResponse]
+        self.__update_queue = queue.Queue(1)
+        self.__lock = Lock()
+
+        self._current_svid = None
+
+        self._stream = None
+        # type: threading.Thread
+        self._stream_thread = None
+
+        # type: queue.Queue
+        self._stop_signal = None
+        self._error = None
+
+    def start(self, block=False):
+        self.__lock.acquire()
+
+        # raise exception if client has already started
+        if self._stream_thread is not None:
+            self.__lock.release()
+            raise X509ClientError("already started")
+
+        self._stop_signal = queue.Queue(1)
+        error_queue = queue.Queue(1)
+
+        self._stream_thread = threading.Thread(target=self._stream_x509_svid,
+                                               args=(self.__update_queue, self._stop_signal, error_queue))
+        self._stream_thread.start()
+        self.__lock.release()
+
+        if block:
+            error = error_queue.get()
+            self.stop()
+            if error is not None:
+                raise X509ClientError('X509Client exited').with_traceback(error.__traceback__)
+
+    def stop(self):
+        self.__lock.acquire()
+
+        # return if client has not started
+        if self._stream_thread is None:
+            self.__lock.release()
+            return
+
+        # stop the x509 streaming thread
+        self._stop_signal.put(1)
+        while True:
+            # if thread fails to join, try re-cancelling grpc stream channel because it blocks thread to finish
+            if self._stream is not None:
+                self._stream.cancel()
+            self._stream_thread.join(1)
+            if not self._stream_thread.is_alive():
+                break
+
+        self._stream_thread = None
+        self.__lock.release()
+
+    def is_alive(self):
+        self.__lock.acquire()
+        res = self._stream_thread is not None and self._stream_thread.is_alive()
+        self.__lock.release()
+        return res
+
+    def current_svid(self):
+        # type: () -> workload.X509SVIDResponse
+        resp = None
+        self.__lock.acquire()
+        if self._current_svid is not None:
+            resp = self._current_svid
+        else:
+            self.config.logger.error("no SVID received yet")
+        self.__lock.release()
+        return resp
+
+    def update_queue(self):
+        # type: () -> 'queue.Queue[workload.X509SVIDResponse]'
+        return self.__update_queue
+
+    def _stream_x509_svid(self, out, stop, exit_error):
+        # type: (queue.Queue, queue.Queue, queue.Queue) -> None
+        metadata = [("workload.spiffe.io", 'true')]
+        last_success = [time.time(), False]
+        backoff = [self.config.__backoff_min__]
+
+        def handle_exception(op, ex):
+            if ex.code() == grpc.StatusCode.INVALID_ARGUMENT:
+                self.config.logger.error("{op} failed with {ex}; aborting".format(op=op, ex=repr(str(ex))))
+                return ex
+            if self.config.fail_on_error:
+                self.config.logger.error("{op} failed with {ex}; aborting".format(op=op, ex=repr(str(ex))))
+                return ex
+
+            if last_success[1]:
+                last_success[1] = False
+                last_success[0] = time.time()
+
+            if self.config.timeout > 0:
+                elapsed_time = time.time() - last_success[0]
+                timeout_left = self.config.timeout - elapsed_time
+                if timeout_left <= 0:
+                    self.config.logger.error(
+                        "{op} failed with {ex}; aborting due to timeout (last success {time: .2f} seconds ago)".format(
+                            op=op, ex=repr(str(ex)), time=elapsed_time))
+                    return X509ClientError("timeout exceeded")
+                if backoff[0] > timeout_left:
+                    backoff[0] = timeout_left
+
+            self.config.logger.error(msg="{op} failed with {ex}; retrying in {time:.2f} seconds"
+                                     .format(op=op, ex=repr(str(ex)), time=backoff[0]))
+            time.sleep(backoff[0])
+
+            backoff[0] = backoff[0] * 1.5
+            if backoff[0] > self.config.backoff_cap:
+                backoff[0] = self.config.backoff_cap
+            return None
+
+        channel = grpc.insecure_channel(self.config.addr, options=self.grpc_options)
+        stub = workload.SpiffeWorkloadAPIStub(channel)
+        self._stream = stub.FetchX509SVID(workload.X509SVIDRequest(), metadata=metadata)
+        while True:
+            try:
+                update = self._stream.next()
+                while True:
+                    try:
+                        if not out.empty():
+                            out.get_nowait()
+                        out.put_nowait(update)
+                        break
+                    except queue.Full or queue.Empty:
+                        pass
+                self._current_svid = update
+                last_success[0] = time.time()
+                last_success[1] = True
+                backoff = [self.config.__backoff_min__]
+            except Exception as e:
+                # return successfully if the exception is triggered by stop signal
+                if not stop.empty():
+                    exit_error.put(None)
+                    return
+                # return exception if critical
+                ee = handle_exception("FetchX509SVID", e)
+                if ee is not None:
+                    exit_error.put(ee)
+                    return
+                # if grpc status code is 'UNAVAILABLE', recreate the grpc channel and stub
+                if hasattr(e, 'code') and callable(e.code):
+                    if e.code() is grpc.StatusCode.UNAVAILABLE:
+                        channel.close()
+                        channel = grpc.insecure_channel(self.config.addr, options=self.grpc_options)
+                        stub = workload.SpiffeWorkloadAPIStub(channel)
+                        self._stream = stub.FetchX509SVID(workload.X509SVIDRequest(), metadata=metadata)
+

miniconda3/envs/ladir/lib/python3.10/sqlite3/__init__.py

@@ -0,0 +1,71 @@
+# pysqlite2/__init__.py: the pysqlite2 package.
+#
+# Copyright (C) 2005 Gerhard Häring <gh@ghaering.de>
+#
+# This file is part of pysqlite.
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the authors be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+"""
+The sqlite3 extension module provides a DB-API 2.0 (PEP 249) compliant
+interface to the SQLite library, and requires SQLite 3.7.15 or newer.
+
+To use the module, start by creating a database Connection object:
+
+    import sqlite3
+    cx = sqlite3.connect("test.db")  # test.db will be created or opened
+
+The special path name ":memory:" can be provided to connect to a transient
+in-memory database:
+
+    cx = sqlite3.connect(":memory:")  # connect to a database in RAM
+
+Once a connection has been established, create a Cursor object and call
+its execute() method to perform SQL queries:
+
+    cu = cx.cursor()
+
+    # create a table
+    cu.execute("create table lang(name, first_appeared)")
+
+    # insert values into a table
+    cu.execute("insert into lang values (?, ?)", ("C", 1972))
+
+    # execute a query and iterate over the result
+    for row in cu.execute("select * from lang"):
+        print(row)
+
+    cx.close()
+
+The sqlite3 module is written by Gerhard Häring <gh@ghaering.de>.
+"""
+
+from sqlite3.dbapi2 import *
+
+
+# bpo-42264: OptimizedUnicode was deprecated in Python 3.10.  It's scheduled
+# for removal in Python 3.12.
+def __getattr__(name):
+    if name == "OptimizedUnicode":
+        import warnings
+        msg = ("""
+            OptimizedUnicode is deprecated and will be removed in Python 3.12.
+            Since Python 3.3 it has simply been an alias for 'str'.
+        """)
+        warnings.warn(msg, DeprecationWarning, stacklevel=2)
+        return str
+    raise AttributeError(f"module 'sqlite3' has no attribute '{name}'")

miniconda3/envs/ladir/lib/python3.10/sqlite3/dbapi2.py

@@ -0,0 +1,103 @@
+# pysqlite2/dbapi2.py: the DB-API 2.0 interface
+#
+# Copyright (C) 2004-2005 Gerhard Häring <gh@ghaering.de>
+#
+# This file is part of pysqlite.
+#
+# This software is provided 'as-is', without any express or implied
+# warranty.  In no event will the authors be held liable for any damages
+# arising from the use of this software.
+#
+# Permission is granted to anyone to use this software for any purpose,
+# including commercial applications, and to alter it and redistribute it
+# freely, subject to the following restrictions:
+#
+# 1. The origin of this software must not be misrepresented; you must not
+#    claim that you wrote the original software. If you use this software
+#    in a product, an acknowledgment in the product documentation would be
+#    appreciated but is not required.
+# 2. Altered source versions must be plainly marked as such, and must not be
+#    misrepresented as being the original software.
+# 3. This notice may not be removed or altered from any source distribution.
+
+import datetime
+import time
+import collections.abc
+
+from _sqlite3 import *
+
+paramstyle = "qmark"
+
+threadsafety = 1
+
+apilevel = "2.0"
+
+Date = datetime.date
+
+Time = datetime.time
+
+Timestamp = datetime.datetime
+
+def DateFromTicks(ticks):
+    return Date(*time.localtime(ticks)[:3])
+
+def TimeFromTicks(ticks):
+    return Time(*time.localtime(ticks)[3:6])
+
+def TimestampFromTicks(ticks):
+    return Timestamp(*time.localtime(ticks)[:6])
+
+version_info = tuple([int(x) for x in version.split(".")])
+sqlite_version_info = tuple([int(x) for x in sqlite_version.split(".")])
+
+Binary = memoryview
+collections.abc.Sequence.register(Row)
+
+def register_adapters_and_converters():
+    def adapt_date(val):
+        return val.isoformat()
+
+    def adapt_datetime(val):
+        return val.isoformat(" ")
+
+    def convert_date(val):
+        return datetime.date(*map(int, val.split(b"-")))
+
+    def convert_timestamp(val):
+        datepart, timepart = val.split(b" ")
+        year, month, day = map(int, datepart.split(b"-"))
+        timepart_full = timepart.split(b".")
+        hours, minutes, seconds = map(int, timepart_full[0].split(b":"))
+        if len(timepart_full) == 2:
+            microseconds = int('{:0<6.6}'.format(timepart_full[1].decode()))
+        else:
+            microseconds = 0
+
+        val = datetime.datetime(year, month, day, hours, minutes, seconds, microseconds)
+        return val
+
+
+    register_adapter(datetime.date, adapt_date)
+    register_adapter(datetime.datetime, adapt_datetime)
+    register_converter("date", convert_date)
+    register_converter("timestamp", convert_timestamp)
+
+register_adapters_and_converters()
+
+# bpo-24464: enable_shared_cache was deprecated in Python 3.10.  It's
+# scheduled for removal in Python 3.12.
+def enable_shared_cache(enable):
+    from _sqlite3 import enable_shared_cache as _old_enable_shared_cache
+    import warnings
+    msg = (
+        "enable_shared_cache is deprecated and will be removed in Python 3.12. "
+        "Shared cache is strongly discouraged by the SQLite 3 documentation. "
+        "If shared cache must be used, open the database in URI mode using"
+        "the cache=shared query parameter."
+    )
+    warnings.warn(msg, DeprecationWarning, stacklevel=2)
+    return _old_enable_shared_cache(enable)
+
+# Clean up namespace
+
+del(register_adapters_and_converters)

miniconda3/envs/ladir/lib/python3.10/sqlite3/dump.py

@@ -0,0 +1,82 @@
+# Mimic the sqlite3 console shell's .dump command
+# Author: Paul Kippes <kippesp@gmail.com>
+
+# Every identifier in sql is quoted based on a comment in sqlite
+# documentation "SQLite adds new keywords from time to time when it
+# takes on new features. So to prevent your code from being broken by
+# future enhancements, you should normally quote any identifier that
+# is an English language word, even if you do not have to."
+
+def _iterdump(connection):
+    """
+    Returns an iterator to the dump of the database in an SQL text format.
+
+    Used to produce an SQL dump of the database.  Useful to save an in-memory
+    database for later restoration.  This function should not be called
+    directly but instead called from the Connection method, iterdump().
+    """
+
+    cu = connection.cursor()
+    yield('BEGIN TRANSACTION;')
+
+    # sqlite_master table contains the SQL CREATE statements for the database.
+    q = """
+        SELECT "name", "type", "sql"
+        FROM "sqlite_master"
+            WHERE "sql" NOT NULL AND
+            "type" == 'table'
+            ORDER BY "name"
+        """
+    schema_res = cu.execute(q)
+    sqlite_sequence = []
+    for table_name, type, sql in schema_res.fetchall():
+        if table_name == 'sqlite_sequence':
+            rows = cu.execute('SELECT * FROM "sqlite_sequence";').fetchall()
+            sqlite_sequence = ['DELETE FROM "sqlite_sequence"']
+            sqlite_sequence += [
+                f'INSERT INTO "sqlite_sequence" VALUES(\'{row[0]}\',{row[1]})'
+                for row in rows
+            ]
+            continue
+        elif table_name == 'sqlite_stat1':
+            yield('ANALYZE "sqlite_master";')
+        elif table_name.startswith('sqlite_'):
+            continue
+        # NOTE: Virtual table support not implemented
+        #elif sql.startswith('CREATE VIRTUAL TABLE'):
+        #    qtable = table_name.replace("'", "''")
+        #    yield("INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"\
+        #        "VALUES('table','{0}','{0}',0,'{1}');".format(
+        #        qtable,
+        #        sql.replace("''")))
+        else:
+            yield('{0};'.format(sql))
+
+        # Build the insert statement for each row of the current table
+        table_name_ident = table_name.replace('"', '""')
+        res = cu.execute('PRAGMA table_info("{0}")'.format(table_name_ident))
+        column_names = [str(table_info[1]) for table_info in res.fetchall()]
+        q = """SELECT 'INSERT INTO "{0}" VALUES({1})' FROM "{0}";""".format(
+            table_name_ident,
+            ",".join("""'||quote("{0}")||'""".format(col.replace('"', '""')) for col in column_names))
+        query_res = cu.execute(q)
+        for row in query_res:
+            yield("{0};".format(row[0]))
+
+    # Now when the type is 'index', 'trigger', or 'view'
+    q = """
+        SELECT "name", "type", "sql"
+        FROM "sqlite_master"
+            WHERE "sql" NOT NULL AND
+            "type" IN ('index', 'trigger', 'view')
+        """
+    schema_res = cu.execute(q)
+    for name, type, sql in schema_res.fetchall():
+        yield('{0};'.format(sql))
+
+    # gh-79009: Yield statements concerning the sqlite_sequence table at the
+    # end of the transaction.
+    for row in sqlite_sequence:
+        yield('{0};'.format(row))
+
+    yield('COMMIT;')

miniconda3/envs/ladir/lib/python3.10/test/__init__.py

@@ -0,0 +1 @@
+# Dummy file to make this directory a package.

miniconda3/envs/ladir/lib/python3.10/test/support/__init__.py

@@ -0,0 +1,2166 @@
+"""Supporting definitions for the Python regression tests."""
+
+if __name__ != 'test.support':
+    raise ImportError('support must be imported from the test package')
+
+import contextlib
+import functools
+import os
+import re
+import stat
+import sys
+import sysconfig
+import time
+import types
+import unittest
+import warnings
+
+from .testresult import get_test_runner
+
+
+try:
+    from _testcapi import unicode_legacy_string
+except ImportError:
+    unicode_legacy_string = None
+
+__all__ = [
+    # globals
+    "PIPE_MAX_SIZE", "verbose", "max_memuse", "use_resources", "failfast",
+    # exceptions
+    "Error", "TestFailed", "TestDidNotRun", "ResourceDenied",
+    # io
+    "record_original_stdout", "get_original_stdout", "captured_stdout",
+    "captured_stdin", "captured_stderr",
+    # unittest
+    "is_resource_enabled", "requires", "requires_freebsd_version",
+    "requires_linux_version", "requires_mac_ver",
+    "check_syntax_error",
+    "BasicTestRunner", "run_unittest", "run_doctest",
+    "requires_gzip", "requires_bz2", "requires_lzma",
+    "bigmemtest", "bigaddrspacetest", "cpython_only", "get_attribute",
+    "requires_IEEE_754", "requires_zlib",
+    "anticipate_failure", "load_package_tests", "detect_api_mismatch",
+    "check__all__", "skip_if_buggy_ucrt_strfptime",
+    "check_disallow_instantiation", "check_sanitizer", "skip_if_sanitizer",
+    # sys
+    "is_jython", "is_android", "check_impl_detail", "unix_shell",
+    "setswitchinterval",
+    # network
+    "open_urlresource",
+    # processes
+    "reap_children",
+    # miscellaneous
+    "run_with_locale", "swap_item", "findfile",
+    "swap_attr", "Matcher", "set_memlimit", "SuppressCrashReport", "sortdict",
+    "run_with_tz", "PGO", "missing_compiler_executable",
+    "ALWAYS_EQ", "NEVER_EQ", "LARGEST", "SMALLEST",
+    "LOOPBACK_TIMEOUT", "INTERNET_TIMEOUT", "SHORT_TIMEOUT", "LONG_TIMEOUT",
+    ]
+
+
+# Timeout in seconds for tests using a network server listening on the network
+# local loopback interface like 127.0.0.1.
+#
+# The timeout is long enough to prevent test failure: it takes into account
+# that the client and the server can run in different threads or even different
+# processes.
+#
+# The timeout should be long enough for connect(), recv() and send() methods
+# of socket.socket.
+LOOPBACK_TIMEOUT = 5.0
+if sys.platform == 'win32' and ' 32 bit (ARM)' in sys.version:
+    # bpo-37553: test_socket.SendfileUsingSendTest is taking longer than 2
+    # seconds on Windows ARM32 buildbot
+    LOOPBACK_TIMEOUT = 10
+elif sys.platform == 'vxworks':
+    LOOPBACK_TIMEOUT = 10
+
+# Timeout in seconds for network requests going to the internet. The timeout is
+# short enough to prevent a test to wait for too long if the internet request
+# is blocked for whatever reason.
+#
+# Usually, a timeout using INTERNET_TIMEOUT should not mark a test as failed,
+# but skip the test instead: see transient_internet().
+INTERNET_TIMEOUT = 60.0
+
+# Timeout in seconds to mark a test as failed if the test takes "too long".
+#
+# The timeout value depends on the regrtest --timeout command line option.
+#
+# If a test using SHORT_TIMEOUT starts to fail randomly on slow buildbots, use
+# LONG_TIMEOUT instead.
+SHORT_TIMEOUT = 30.0
+
+# Timeout in seconds to detect when a test hangs.
+#
+# It is long enough to reduce the risk of test failure on the slowest Python
+# buildbots. It should not be used to mark a test as failed if the test takes
+# "too long". The timeout value depends on the regrtest --timeout command line
+# option.
+LONG_TIMEOUT = 5 * 60.0
+
+
+class Error(Exception):
+    """Base class for regression test exceptions."""
+
+class TestFailed(Error):
+    """Test failed."""
+
+class TestFailedWithDetails(TestFailed):
+    """Test failed."""
+    def __init__(self, msg, errors, failures):
+        self.msg = msg
+        self.errors = errors
+        self.failures = failures
+        super().__init__(msg, errors, failures)
+
+    def __str__(self):
+        return self.msg
+
+class TestDidNotRun(Error):
+    """Test did not run any subtests."""
+
+class ResourceDenied(unittest.SkipTest):
+    """Test skipped because it requested a disallowed resource.
+
+    This is raised when a test calls requires() for a resource that
+    has not be enabled.  It is used to distinguish between expected
+    and unexpected skips.
+    """
+
+def anticipate_failure(condition):
+    """Decorator to mark a test that is known to be broken in some cases
+
+       Any use of this decorator should have a comment identifying the
+       associated tracker issue.
+    """
+    if condition:
+        return unittest.expectedFailure
+    return lambda f: f
+
+def load_package_tests(pkg_dir, loader, standard_tests, pattern):
+    """Generic load_tests implementation for simple test packages.
+
+    Most packages can implement load_tests using this function as follows:
+
+       def load_tests(*args):
+           return load_package_tests(os.path.dirname(__file__), *args)
+    """
+    if pattern is None:
+        pattern = "test*"
+    top_dir = os.path.dirname(              # Lib
+                  os.path.dirname(              # test
+                      os.path.dirname(__file__)))   # support
+    package_tests = loader.discover(start_dir=pkg_dir,
+                                    top_level_dir=top_dir,
+                                    pattern=pattern)
+    standard_tests.addTests(package_tests)
+    return standard_tests
+
+
+def get_attribute(obj, name):
+    """Get an attribute, raising SkipTest if AttributeError is raised."""
+    try:
+        attribute = getattr(obj, name)
+    except AttributeError:
+        raise unittest.SkipTest("object %r has no attribute %r" % (obj, name))
+    else:
+        return attribute
+
+verbose = 1              # Flag set to 0 by regrtest.py
+use_resources = None     # Flag set to [] by regrtest.py
+max_memuse = 0           # Disable bigmem tests (they will still be run with
+                         # small sizes, to make sure they work.)
+real_max_memuse = 0
+junit_xml_list = None    # list of testsuite XML elements
+failfast = False
+
+# _original_stdout is meant to hold stdout at the time regrtest began.
+# This may be "the real" stdout, or IDLE's emulation of stdout, or whatever.
+# The point is to have some flavor of stdout the user can actually see.
+_original_stdout = None
+def record_original_stdout(stdout):
+    global _original_stdout
+    _original_stdout = stdout
+
+def get_original_stdout():
+    return _original_stdout or sys.stdout
+
+
+def _force_run(path, func, *args):
+    try:
+        return func(*args)
+    except OSError as err:
+        if verbose >= 2:
+            print('%s: %s' % (err.__class__.__name__, err))
+            print('re-run %s%r' % (func.__name__, args))
+        os.chmod(path, stat.S_IRWXU)
+        return func(*args)
+
+
+# Check whether a gui is actually available
+def _is_gui_available():
+    if hasattr(_is_gui_available, 'result'):
+        return _is_gui_available.result
+    import platform
+    reason = None
+    if sys.platform.startswith('win') and platform.win32_is_iot():
+        reason = "gui is not available on Windows IoT Core"
+    elif sys.platform.startswith('win'):
+        # if Python is running as a service (such as the buildbot service),
+        # gui interaction may be disallowed
+        import ctypes
+        import ctypes.wintypes
+        UOI_FLAGS = 1
+        WSF_VISIBLE = 0x0001
+        class USEROBJECTFLAGS(ctypes.Structure):
+            _fields_ = [("fInherit", ctypes.wintypes.BOOL),
+                        ("fReserved", ctypes.wintypes.BOOL),
+                        ("dwFlags", ctypes.wintypes.DWORD)]
+        dll = ctypes.windll.user32
+        h = dll.GetProcessWindowStation()
+        if not h:
+            raise ctypes.WinError()
+        uof = USEROBJECTFLAGS()
+        needed = ctypes.wintypes.DWORD()
+        res = dll.GetUserObjectInformationW(h,
+            UOI_FLAGS,
+            ctypes.byref(uof),
+            ctypes.sizeof(uof),
+            ctypes.byref(needed))
+        if not res:
+            raise ctypes.WinError()
+        if not bool(uof.dwFlags & WSF_VISIBLE):
+            reason = "gui not available (WSF_VISIBLE flag not set)"
+    elif sys.platform == 'darwin':
+        # The Aqua Tk implementations on OS X can abort the process if
+        # being called in an environment where a window server connection
+        # cannot be made, for instance when invoked by a buildbot or ssh
+        # process not running under the same user id as the current console
+        # user.  To avoid that, raise an exception if the window manager
+        # connection is not available.
+        from ctypes import cdll, c_int, pointer, Structure
+        from ctypes.util import find_library
+
+        app_services = cdll.LoadLibrary(find_library("ApplicationServices"))
+
+        if app_services.CGMainDisplayID() == 0:
+            reason = "gui tests cannot run without OS X window manager"
+        else:
+            class ProcessSerialNumber(Structure):
+                _fields_ = [("highLongOfPSN", c_int),
+                            ("lowLongOfPSN", c_int)]
+            psn = ProcessSerialNumber()
+            psn_p = pointer(psn)
+            if (  (app_services.GetCurrentProcess(psn_p) < 0) or
+                  (app_services.SetFrontProcess(psn_p) < 0) ):
+                reason = "cannot run without OS X gui process"
+
+    # check on every platform whether tkinter can actually do anything
+    if not reason:
+        try:
+            from tkinter import Tk
+            root = Tk()
+            root.withdraw()
+            root.update()
+            root.destroy()
+        except Exception as e:
+            err_string = str(e)
+            if len(err_string) > 50:
+                err_string = err_string[:50] + ' [...]'
+            reason = 'Tk unavailable due to {}: {}'.format(type(e).__name__,
+                                                           err_string)
+
+    _is_gui_available.reason = reason
+    _is_gui_available.result = not reason
+
+    return _is_gui_available.result
+
+def is_resource_enabled(resource):
+    """Test whether a resource is enabled.
+
+    Known resources are set by regrtest.py.  If not running under regrtest.py,
+    all resources are assumed enabled unless use_resources has been set.
+    """
+    return use_resources is None or resource in use_resources
+
+def requires(resource, msg=None):
+    """Raise ResourceDenied if the specified resource is not available."""
+    if not is_resource_enabled(resource):
+        if msg is None:
+            msg = "Use of the %r resource not enabled" % resource
+        raise ResourceDenied(msg)
+    if resource == 'gui' and not _is_gui_available():
+        raise ResourceDenied(_is_gui_available.reason)
+
+def _get_kernel_version(sysname="Linux"):
+    import platform
+    if platform.system() != sysname:
+        return None
+    version_txt = platform.release().split('-', 1)[0]
+    try:
+        return tuple(map(int, version_txt.split('.')))
+    except ValueError:
+        return None
+
+def _requires_unix_version(sysname, min_version):
+    """Decorator raising SkipTest if the OS is `sysname` and the version is less
+    than `min_version`.
+
+    For example, @_requires_unix_version('FreeBSD', (7, 2)) raises SkipTest if
+    the FreeBSD version is less than 7.2.
+    """
+    import platform
+    min_version_txt = '.'.join(map(str, min_version))
+    version_txt = platform.release().split('-', 1)[0]
+    if platform.system() == sysname:
+        try:
+            version = tuple(map(int, version_txt.split('.')))
+        except ValueError:
+            skip = False
+        else:
+            skip = version < min_version
+    else:
+        skip = False
+
+    return unittest.skipIf(
+        skip,
+        f"{sysname} version {min_version_txt} or higher required, not "
+        f"{version_txt}"
+    )
+
+
+def requires_freebsd_version(*min_version):
+    """Decorator raising SkipTest if the OS is FreeBSD and the FreeBSD version is
+    less than `min_version`.
+
+    For example, @requires_freebsd_version(7, 2) raises SkipTest if the FreeBSD
+    version is less than 7.2.
+    """
+    return _requires_unix_version('FreeBSD', min_version)
+
+def requires_linux_version(*min_version):
+    """Decorator raising SkipTest if the OS is Linux and the Linux version is
+    less than `min_version`.
+
+    For example, @requires_linux_version(2, 6, 32) raises SkipTest if the Linux
+    version is less than 2.6.32.
+    """
+    return _requires_unix_version('Linux', min_version)
+
+def requires_mac_ver(*min_version):
+    """Decorator raising SkipTest if the OS is Mac OS X and the OS X
+    version if less than min_version.
+
+    For example, @requires_mac_ver(10, 5) raises SkipTest if the OS X version
+    is lesser than 10.5.
+    """
+    def decorator(func):
+        @functools.wraps(func)
+        def wrapper(*args, **kw):
+            if sys.platform == 'darwin':
+                import platform
+                version_txt = platform.mac_ver()[0]
+                try:
+                    version = tuple(map(int, version_txt.split('.')))
+                except ValueError:
+                    pass
+                else:
+                    if version < min_version:
+                        min_version_txt = '.'.join(map(str, min_version))
+                        raise unittest.SkipTest(
+                            "Mac OS X %s or higher required, not %s"
+                            % (min_version_txt, version_txt))
+            return func(*args, **kw)
+        wrapper.min_version = min_version
+        return wrapper
+    return decorator
+
+
+def check_sanitizer(*, address=False, memory=False, ub=False):
+    """Returns True if Python is compiled with sanitizer support"""
+    if not (address or memory or ub):
+        raise ValueError('At least one of address, memory, or ub must be True')
+
+
+    _cflags = sysconfig.get_config_var('CFLAGS') or ''
+    _config_args = sysconfig.get_config_var('CONFIG_ARGS') or ''
+    memory_sanitizer = (
+        '-fsanitize=memory' in _cflags or
+        '--with-memory-sanitizer' in _config_args
+    )
+    address_sanitizer = (
+        '-fsanitize=address' in _cflags or
+        '--with-memory-sanitizer' in _config_args
+    )
+    ub_sanitizer = (
+        '-fsanitize=undefined' in _cflags or
+        '--with-undefined-behavior-sanitizer' in _config_args
+    )
+    return (
+        (memory and memory_sanitizer) or
+        (address and address_sanitizer) or
+        (ub and ub_sanitizer)
+    )
+
+
+def skip_if_sanitizer(reason=None, *, address=False, memory=False, ub=False):
+    """Decorator raising SkipTest if running with a sanitizer active."""
+    if not reason:
+        reason = 'not working with sanitizers active'
+    skip = check_sanitizer(address=address, memory=memory, ub=ub)
+    return unittest.skipIf(skip, reason)
+
+
+def system_must_validate_cert(f):
+    """Skip the test on TLS certificate validation failures."""
+    @functools.wraps(f)
+    def dec(*args, **kwargs):
+        try:
+            f(*args, **kwargs)
+        except OSError as e:
+            if "CERTIFICATE_VERIFY_FAILED" in str(e):
+                raise unittest.SkipTest("system does not contain "
+                                        "necessary certificates")
+            raise
+    return dec
+
+# A constant likely larger than the underlying OS pipe buffer size, to
+# make writes blocking.
+# Windows limit seems to be around 512 B, and many Unix kernels have a
+# 64 KiB pipe buffer size or 16 * PAGE_SIZE: take a few megs to be sure.
+# (see issue #17835 for a discussion of this number).
+PIPE_MAX_SIZE = 4 * 1024 * 1024 + 1
+
+# A constant likely larger than the underlying OS socket buffer size, to make
+# writes blocking.
+# The socket buffer sizes can usually be tuned system-wide (e.g. through sysctl
+# on Linux), or on a per-socket basis (SO_SNDBUF/SO_RCVBUF).  See issue #18643
+# for a discussion of this number.
+SOCK_MAX_SIZE = 16 * 1024 * 1024 + 1
+
+# decorator for skipping tests on non-IEEE 754 platforms
+requires_IEEE_754 = unittest.skipUnless(
+    float.__getformat__("double").startswith("IEEE"),
+    "test requires IEEE 754 doubles")
+
+def requires_zlib(reason='requires zlib'):
+    try:
+        import zlib
+    except ImportError:
+        zlib = None
+    return unittest.skipUnless(zlib, reason)
+
+def requires_gzip(reason='requires gzip'):
+    try:
+        import gzip
+    except ImportError:
+        gzip = None
+    return unittest.skipUnless(gzip, reason)
+
+def requires_bz2(reason='requires bz2'):
+    try:
+        import bz2
+    except ImportError:
+        bz2 = None
+    return unittest.skipUnless(bz2, reason)
+
+def requires_lzma(reason='requires lzma'):
+    try:
+        import lzma
+    except ImportError:
+        lzma = None
+    return unittest.skipUnless(lzma, reason)
+
+requires_legacy_unicode_capi = unittest.skipUnless(unicode_legacy_string,
+                        'requires legacy Unicode C API')
+
+is_jython = sys.platform.startswith('java')
+
+is_android = hasattr(sys, 'getandroidapilevel')
+
+if sys.platform not in ('win32', 'vxworks'):
+    unix_shell = '/system/bin/sh' if is_android else '/bin/sh'
+else:
+    unix_shell = None
+
+# Define the URL of a dedicated HTTP server for the network tests.
+# The URL must use clear-text HTTP: no redirection to encrypted HTTPS.
+TEST_HTTP_URL = "http://www.pythontest.net"
+
+# Set by libregrtest/main.py so we can skip tests that are not
+# useful for PGO
+PGO = False
+
+# Set by libregrtest/main.py if we are running the extended (time consuming)
+# PGO task.  If this is True, PGO is also True.
+PGO_EXTENDED = False
+
+# TEST_HOME_DIR refers to the top level directory of the "test" package
+# that contains Python's regression test suite
+TEST_SUPPORT_DIR = os.path.dirname(os.path.abspath(__file__))
+TEST_HOME_DIR = os.path.dirname(TEST_SUPPORT_DIR)
+
+# TEST_DATA_DIR is used as a target download location for remote resources
+TEST_DATA_DIR = os.path.join(TEST_HOME_DIR, "data")
+
+
+def darwin_malloc_err_warning(test_name):
+    """Assure user that loud errors generated by macOS libc's malloc are
+    expected."""
+    if sys.platform != 'darwin':
+        return
+
+    import shutil
+    msg = ' NOTICE '
+    detail = (f'{test_name} may generate "malloc can\'t allocate region"\n'
+              'warnings on macOS systems. This behavior is known. Do not\n'
+              'report a bug unless tests are also failing. See bpo-40928.')
+
+    padding, _ = shutil.get_terminal_size()
+    print(msg.center(padding, '-'))
+    print(detail)
+    print('-' * padding)
+
+
+def findfile(filename, subdir=None):
+    """Try to find a file on sys.path or in the test directory.  If it is not
+    found the argument passed to the function is returned (this does not
+    necessarily signal failure; could still be the legitimate path).
+
+    Setting *subdir* indicates a relative path to use to find the file
+    rather than looking directly in the path directories.
+    """
+    if os.path.isabs(filename):
+        return filename
+    if subdir is not None:
+        filename = os.path.join(subdir, filename)
+    path = [TEST_HOME_DIR] + sys.path
+    for dn in path:
+        fn = os.path.join(dn, filename)
+        if os.path.exists(fn): return fn
+    return filename
+
+
+def sortdict(dict):
+    "Like repr(dict), but in sorted order."
+    items = sorted(dict.items())
+    reprpairs = ["%r: %r" % pair for pair in items]
+    withcommas = ", ".join(reprpairs)
+    return "{%s}" % withcommas
+
+def check_syntax_error(testcase, statement, errtext='', *, lineno=None, offset=None):
+    with testcase.assertRaisesRegex(SyntaxError, errtext) as cm:
+        compile(statement, '<test string>', 'exec')
+    err = cm.exception
+    testcase.assertIsNotNone(err.lineno)
+    if lineno is not None:
+        testcase.assertEqual(err.lineno, lineno)
+    testcase.assertIsNotNone(err.offset)
+    if offset is not None:
+        testcase.assertEqual(err.offset, offset)
+
+
+def open_urlresource(url, *args, **kw):
+    import urllib.request, urllib.parse
+    from .os_helper import unlink
+    try:
+        import gzip
+    except ImportError:
+        gzip = None
+
+    check = kw.pop('check', None)
+
+    filename = urllib.parse.urlparse(url)[2].split('/')[-1] # '/': it's URL!
+
+    fn = os.path.join(TEST_DATA_DIR, filename)
+
+    def check_valid_file(fn):
+        f = open(fn, *args, **kw)
+        if check is None:
+            return f
+        elif check(f):
+            f.seek(0)
+            return f
+        f.close()
+
+    if os.path.exists(fn):
+        f = check_valid_file(fn)
+        if f is not None:
+            return f
+        unlink(fn)
+
+    # Verify the requirement before downloading the file
+    requires('urlfetch')
+
+    if verbose:
+        print('\tfetching %s ...' % url, file=get_original_stdout())
+    opener = urllib.request.build_opener()
+    if gzip:
+        opener.addheaders.append(('Accept-Encoding', 'gzip'))
+    f = opener.open(url, timeout=INTERNET_TIMEOUT)
+    if gzip and f.headers.get('Content-Encoding') == 'gzip':
+        f = gzip.GzipFile(fileobj=f)
+    try:
+        with open(fn, "wb") as out:
+            s = f.read()
+            while s:
+                out.write(s)
+                s = f.read()
+    finally:
+        f.close()
+
+    f = check_valid_file(fn)
+    if f is not None:
+        return f
+    raise TestFailed('invalid resource %r' % fn)
+
+
+@contextlib.contextmanager
+def captured_output(stream_name):
+    """Return a context manager used by captured_stdout/stdin/stderr
+    that temporarily replaces the sys stream *stream_name* with a StringIO."""
+    import io
+    orig_stdout = getattr(sys, stream_name)
+    setattr(sys, stream_name, io.StringIO())
+    try:
+        yield getattr(sys, stream_name)
+    finally:
+        setattr(sys, stream_name, orig_stdout)
+
+def captured_stdout():
+    """Capture the output of sys.stdout:
+
+       with captured_stdout() as stdout:
+           print("hello")
+       self.assertEqual(stdout.getvalue(), "hello\\n")
+    """
+    return captured_output("stdout")
+
+def captured_stderr():
+    """Capture the output of sys.stderr:
+
+       with captured_stderr() as stderr:
+           print("hello", file=sys.stderr)
+       self.assertEqual(stderr.getvalue(), "hello\\n")
+    """
+    return captured_output("stderr")
+
+def captured_stdin():
+    """Capture the input to sys.stdin:
+
+       with captured_stdin() as stdin:
+           stdin.write('hello\\n')
+           stdin.seek(0)
+           # call test code that consumes from sys.stdin
+           captured = input()
+       self.assertEqual(captured, "hello")
+    """
+    return captured_output("stdin")
+
+
+def gc_collect():
+    """Force as many objects as possible to be collected.
+
+    In non-CPython implementations of Python, this is needed because timely
+    deallocation is not guaranteed by the garbage collector.  (Even in CPython
+    this can be the case in case of reference cycles.)  This means that __del__
+    methods may be called later than expected and weakrefs may remain alive for
+    longer than expected.  This function tries its best to force all garbage
+    objects to disappear.
+    """
+    import gc
+    gc.collect()
+    if is_jython:
+        time.sleep(0.1)
+    gc.collect()
+    gc.collect()
+
+@contextlib.contextmanager
+def disable_gc():
+    import gc
+    have_gc = gc.isenabled()
+    gc.disable()
+    try:
+        yield
+    finally:
+        if have_gc:
+            gc.enable()
+
+
+def python_is_optimized():
+    """Find if Python was built with optimizations."""
+    cflags = sysconfig.get_config_var('PY_CFLAGS') or ''
+    final_opt = ""
+    for opt in cflags.split():
+        if opt.startswith('-O'):
+            final_opt = opt
+    return final_opt not in ('', '-O0', '-Og')
+
+
+_header = 'nP'
+_align = '0n'
+if hasattr(sys, "getobjects"):
+    _header = '2P' + _header
+    _align = '0P'
+_vheader = _header + 'n'
+
+def calcobjsize(fmt):
+    import struct
+    return struct.calcsize(_header + fmt + _align)
+
+def calcvobjsize(fmt):
+    import struct
+    return struct.calcsize(_vheader + fmt + _align)
+
+
+_TPFLAGS_HAVE_GC = 1<<14
+_TPFLAGS_HEAPTYPE = 1<<9
+
+def check_sizeof(test, o, size):
+    import _testinternalcapi
+    result = sys.getsizeof(o)
+    # add GC header size
+    if ((type(o) == type) and (o.__flags__ & _TPFLAGS_HEAPTYPE) or\
+        ((type(o) != type) and (type(o).__flags__ & _TPFLAGS_HAVE_GC))):
+        size += _testinternalcapi.SIZEOF_PYGC_HEAD
+    msg = 'wrong size for %s: got %d, expected %d' \
+            % (type(o), result, size)
+    test.assertEqual(result, size, msg)
+
+def subTests(arg_names, arg_values, /, *, _do_cleanups=False):
+    """Run multiple subtests with different parameters.
+    """
+    single_param = False
+    if isinstance(arg_names, str):
+        arg_names = arg_names.replace(',',' ').split()
+        if len(arg_names) == 1:
+            single_param = True
+    arg_values = tuple(arg_values)
+    def decorator(func):
+        if isinstance(func, type):
+            raise TypeError('subTests() can only decorate methods, not classes')
+        @functools.wraps(func)
+        def wrapper(self, /, *args, **kwargs):
+            for values in arg_values:
+                if single_param:
+                    values = (values,)
+                subtest_kwargs = dict(zip(arg_names, values))
+                with self.subTest(**subtest_kwargs):
+                    func(self, *args, **kwargs, **subtest_kwargs)
+                if _do_cleanups:
+                    self.doCleanups()
+        return wrapper
+    return decorator
+
+#=======================================================================
+# Decorator for running a function in a different locale, correctly resetting
+# it afterwards.
+
+@contextlib.contextmanager
+def run_with_locale(catstr, *locales):
+            try:
+                import locale
+                category = getattr(locale, catstr)
+                orig_locale = locale.setlocale(category)
+            except AttributeError:
+                # if the test author gives us an invalid category string
+                raise
+            except:
+                # cannot retrieve original locale, so do nothing
+                locale = orig_locale = None
+            else:
+                for loc in locales:
+                    try:
+                        locale.setlocale(category, loc)
+                        break
+                    except:
+                        pass
+
+            try:
+                yield
+            finally:
+                if locale and orig_locale:
+                    locale.setlocale(category, orig_locale)
+
+#=======================================================================
+# Decorator for running a function in a specific timezone, correctly
+# resetting it afterwards.
+
+def run_with_tz(tz):
+    def decorator(func):
+        def inner(*args, **kwds):
+            try:
+                tzset = time.tzset
+            except AttributeError:
+                raise unittest.SkipTest("tzset required")
+            if 'TZ' in os.environ:
+                orig_tz = os.environ['TZ']
+            else:
+                orig_tz = None
+            os.environ['TZ'] = tz
+            tzset()
+
+            # now run the function, resetting the tz on exceptions
+            try:
+                return func(*args, **kwds)
+            finally:
+                if orig_tz is None:
+                    del os.environ['TZ']
+                else:
+                    os.environ['TZ'] = orig_tz
+                time.tzset()
+
+        inner.__name__ = func.__name__
+        inner.__doc__ = func.__doc__
+        return inner
+    return decorator
+
+#=======================================================================
+# Big-memory-test support. Separate from 'resources' because memory use
+# should be configurable.
+
+# Some handy shorthands. Note that these are used for byte-limits as well
+# as size-limits, in the various bigmem tests
+_1M = 1024*1024
+_1G = 1024 * _1M
+_2G = 2 * _1G
+_4G = 4 * _1G
+
+MAX_Py_ssize_t = sys.maxsize
+
+def set_memlimit(limit):
+    global max_memuse
+    global real_max_memuse
+    sizes = {
+        'k': 1024,
+        'm': _1M,
+        'g': _1G,
+        't': 1024*_1G,
+    }
+    m = re.match(r'(\d+(\.\d+)?) (K|M|G|T)b?$', limit,
+                 re.IGNORECASE | re.VERBOSE)
+    if m is None:
+        raise ValueError('Invalid memory limit %r' % (limit,))
+    memlimit = int(float(m.group(1)) * sizes[m.group(3).lower()])
+    real_max_memuse = memlimit
+    if memlimit > MAX_Py_ssize_t:
+        memlimit = MAX_Py_ssize_t
+    if memlimit < _2G - 1:
+        raise ValueError('Memory limit %r too low to be useful' % (limit,))
+    max_memuse = memlimit
+
+class _MemoryWatchdog:
+    """An object which periodically watches the process' memory consumption
+    and prints it out.
+    """
+
+    def __init__(self):
+        self.procfile = '/proc/{pid}/statm'.format(pid=os.getpid())
+        self.started = False
+
+    def start(self):
+        import warnings
+        try:
+            f = open(self.procfile, 'r')
+        except OSError as e:
+            warnings.warn('/proc not available for stats: {}'.format(e),
+                          RuntimeWarning)
+            sys.stderr.flush()
+            return
+
+        import subprocess
+        with f:
+            watchdog_script = findfile("memory_watchdog.py")
+            self.mem_watchdog = subprocess.Popen([sys.executable, watchdog_script],
+                                                 stdin=f,
+                                                 stderr=subprocess.DEVNULL)
+        self.started = True
+
+    def stop(self):
+        if self.started:
+            self.mem_watchdog.terminate()
+            self.mem_watchdog.wait()
+
+
+def bigmemtest(size, memuse, dry_run=True):
+    """Decorator for bigmem tests.
+
+    'size' is a requested size for the test (in arbitrary, test-interpreted
+    units.) 'memuse' is the number of bytes per unit for the test, or a good
+    estimate of it. For example, a test that needs two byte buffers, of 4 GiB
+    each, could be decorated with @bigmemtest(size=_4G, memuse=2).
+
+    The 'size' argument is normally passed to the decorated test method as an
+    extra argument. If 'dry_run' is true, the value passed to the test method
+    may be less than the requested value. If 'dry_run' is false, it means the
+    test doesn't support dummy runs when -M is not specified.
+    """
+    def decorator(f):
+        def wrapper(self):
+            size = wrapper.size
+            memuse = wrapper.memuse
+            if not real_max_memuse:
+                maxsize = 5147
+            else:
+                maxsize = size
+
+            if ((real_max_memuse or not dry_run)
+                and real_max_memuse < maxsize * memuse):
+                raise unittest.SkipTest(
+                    "not enough memory: %.1fG minimum needed"
+                    % (size * memuse / (1024 ** 3)))
+
+            if real_max_memuse and verbose:
+                print()
+                print(" ... expected peak memory use: {peak:.1f}G"
+                      .format(peak=size * memuse / (1024 ** 3)))
+                watchdog = _MemoryWatchdog()
+                watchdog.start()
+            else:
+                watchdog = None
+
+            try:
+                return f(self, maxsize)
+            finally:
+                if watchdog:
+                    watchdog.stop()
+
+        wrapper.size = size
+        wrapper.memuse = memuse
+        return wrapper
+    return decorator
+
+def bigaddrspacetest(f):
+    """Decorator for tests that fill the address space."""
+    def wrapper(self):
+        if max_memuse < MAX_Py_ssize_t:
+            if MAX_Py_ssize_t >= 2**63 - 1 and max_memuse >= 2**31:
+                raise unittest.SkipTest(
+                    "not enough memory: try a 32-bit build instead")
+            else:
+                raise unittest.SkipTest(
+                    "not enough memory: %.1fG minimum needed"
+                    % (MAX_Py_ssize_t / (1024 ** 3)))
+        else:
+            return f(self)
+    return wrapper
+
+#=======================================================================
+# unittest integration.
+
+class BasicTestRunner:
+    def run(self, test):
+        result = unittest.TestResult()
+        test(result)
+        return result
+
+def _id(obj):
+    return obj
+
+def requires_resource(resource):
+    if resource == 'gui' and not _is_gui_available():
+        return unittest.skip(_is_gui_available.reason)
+    if is_resource_enabled(resource):
+        return _id
+    else:
+        return unittest.skip("resource {0!r} is not enabled".format(resource))
+
+def cpython_only(test):
+    """
+    Decorator for tests only applicable on CPython.
+    """
+    return impl_detail(cpython=True)(test)
+
+def impl_detail(msg=None, **guards):
+    if check_impl_detail(**guards):
+        return _id
+    if msg is None:
+        guardnames, default = _parse_guards(guards)
+        if default:
+            msg = "implementation detail not available on {0}"
+        else:
+            msg = "implementation detail specific to {0}"
+        guardnames = sorted(guardnames.keys())
+        msg = msg.format(' or '.join(guardnames))
+    return unittest.skip(msg)
+
+def _parse_guards(guards):
+    # Returns a tuple ({platform_name: run_me}, default_value)
+    if not guards:
+        return ({'cpython': True}, False)
+    is_true = list(guards.values())[0]
+    assert list(guards.values()) == [is_true] * len(guards)   # all True or all False
+    return (guards, not is_true)
+
+# Use the following check to guard CPython's implementation-specific tests --
+# or to run them only on the implementation(s) guarded by the arguments.
+def check_impl_detail(**guards):
+    """This function returns True or False depending on the host platform.
+       Examples:
+          if check_impl_detail():               # only on CPython (default)
+          if check_impl_detail(jython=True):    # only on Jython
+          if check_impl_detail(cpython=False):  # everywhere except on CPython
+    """
+    guards, default = _parse_guards(guards)
+    return guards.get(sys.implementation.name, default)
+
+
+def no_tracing(func):
+    """Decorator to temporarily turn off tracing for the duration of a test."""
+    if not hasattr(sys, 'gettrace'):
+        return func
+    else:
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            original_trace = sys.gettrace()
+            try:
+                sys.settrace(None)
+                return func(*args, **kwargs)
+            finally:
+                sys.settrace(original_trace)
+        return wrapper
+
+
+def refcount_test(test):
+    """Decorator for tests which involve reference counting.
+
+    To start, the decorator does not run the test if is not run by CPython.
+    After that, any trace function is unset during the test to prevent
+    unexpected refcounts caused by the trace function.
+
+    """
+    return no_tracing(cpython_only(test))
+
+
+def _filter_suite(suite, pred):
+    """Recursively filter test cases in a suite based on a predicate."""
+    newtests = []
+    for test in suite._tests:
+        if isinstance(test, unittest.TestSuite):
+            _filter_suite(test, pred)
+            newtests.append(test)
+        else:
+            if pred(test):
+                newtests.append(test)
+    suite._tests = newtests
+
+def _run_suite(suite):
+    """Run tests from a unittest.TestSuite-derived class."""
+    runner = get_test_runner(sys.stdout,
+                             verbosity=verbose,
+                             capture_output=(junit_xml_list is not None))
+
+    result = runner.run(suite)
+
+    if junit_xml_list is not None:
+        junit_xml_list.append(result.get_xml_element())
+
+    if not result.testsRun and not result.skipped:
+        raise TestDidNotRun
+    if not result.wasSuccessful():
+        if len(result.errors) == 1 and not result.failures:
+            err = result.errors[0][1]
+        elif len(result.failures) == 1 and not result.errors:
+            err = result.failures[0][1]
+        else:
+            err = "multiple errors occurred"
+            if not verbose: err += "; run in verbose mode for details"
+        errors = [(str(tc), exc_str) for tc, exc_str in result.errors]
+        failures = [(str(tc), exc_str) for tc, exc_str in result.failures]
+        raise TestFailedWithDetails(err, errors, failures)
+
+
+# By default, don't filter tests
+_match_test_func = None
+
+_accept_test_patterns = None
+_ignore_test_patterns = None
+
+
+def match_test(test):
+    # Function used by support.run_unittest() and regrtest --list-cases
+    if _match_test_func is None:
+        return True
+    else:
+        return _match_test_func(test.id())
+
+
+def _is_full_match_test(pattern):
+    # If a pattern contains at least one dot, it's considered
+    # as a full test identifier.
+    # Example: 'test.test_os.FileTests.test_access'.
+    #
+    # ignore patterns which contain fnmatch patterns: '*', '?', '[...]'
+    # or '[!...]'. For example, ignore 'test_access*'.
+    return ('.' in pattern) and (not re.search(r'[?*\[\]]', pattern))
+
+
+def set_match_tests(accept_patterns=None, ignore_patterns=None):
+    global _match_test_func, _accept_test_patterns, _ignore_test_patterns
+
+
+    if accept_patterns is None:
+        accept_patterns = ()
+    if ignore_patterns is None:
+        ignore_patterns = ()
+
+    accept_func = ignore_func = None
+
+    if accept_patterns != _accept_test_patterns:
+        accept_patterns, accept_func = _compile_match_function(accept_patterns)
+    if ignore_patterns != _ignore_test_patterns:
+        ignore_patterns, ignore_func = _compile_match_function(ignore_patterns)
+
+    # Create a copy since patterns can be mutable and so modified later
+    _accept_test_patterns = tuple(accept_patterns)
+    _ignore_test_patterns = tuple(ignore_patterns)
+
+    if accept_func is not None or ignore_func is not None:
+        def match_function(test_id):
+            accept = True
+            ignore = False
+            if accept_func:
+                accept = accept_func(test_id)
+            if ignore_func:
+                ignore = ignore_func(test_id)
+            return accept and not ignore
+
+        _match_test_func = match_function
+
+
+def _compile_match_function(patterns):
+    if not patterns:
+        func = None
+        # set_match_tests(None) behaves as set_match_tests(())
+        patterns = ()
+    elif all(map(_is_full_match_test, patterns)):
+        # Simple case: all patterns are full test identifier.
+        # The test.bisect_cmd utility only uses such full test identifiers.
+        func = set(patterns).__contains__
+    else:
+        import fnmatch
+        regex = '|'.join(map(fnmatch.translate, patterns))
+        # The search *is* case sensitive on purpose:
+        # don't use flags=re.IGNORECASE
+        regex_match = re.compile(regex).match
+
+        def match_test_regex(test_id):
+            if regex_match(test_id):
+                # The regex matches the whole identifier, for example
+                # 'test.test_os.FileTests.test_access'.
+                return True
+            else:
+                # Try to match parts of the test identifier.
+                # For example, split 'test.test_os.FileTests.test_access'
+                # into: 'test', 'test_os', 'FileTests' and 'test_access'.
+                return any(map(regex_match, test_id.split(".")))
+
+        func = match_test_regex
+
+    return patterns, func
+
+
+def run_unittest(*classes):
+    """Run tests from unittest.TestCase-derived classes."""
+    valid_types = (unittest.TestSuite, unittest.TestCase)
+    suite = unittest.TestSuite()
+    for cls in classes:
+        if isinstance(cls, str):
+            if cls in sys.modules:
+                suite.addTest(unittest.findTestCases(sys.modules[cls]))
+            else:
+                raise ValueError("str arguments must be keys in sys.modules")
+        elif isinstance(cls, valid_types):
+            suite.addTest(cls)
+        else:
+            suite.addTest(unittest.makeSuite(cls))
+    _filter_suite(suite, match_test)
+    _run_suite(suite)
+
+#=======================================================================
+# Check for the presence of docstrings.
+
+# Rather than trying to enumerate all the cases where docstrings may be
+# disabled, we just check for that directly
+
+def _check_docstrings():
+    """Just used to check if docstrings are enabled"""
+
+MISSING_C_DOCSTRINGS = (check_impl_detail() and
+                        sys.platform != 'win32' and
+                        not sysconfig.get_config_var('WITH_DOC_STRINGS'))
+
+HAVE_DOCSTRINGS = (_check_docstrings.__doc__ is not None and
+                   not MISSING_C_DOCSTRINGS)
+
+requires_docstrings = unittest.skipUnless(HAVE_DOCSTRINGS,
+                                          "test requires docstrings")
+
+
+#=======================================================================
+# doctest driver.
+
+def run_doctest(module, verbosity=None, optionflags=0):
+    """Run doctest on the given module.  Return (#failures, #tests).
+
+    If optional argument verbosity is not specified (or is None), pass
+    support's belief about verbosity on to doctest.  Else doctest's
+    usual behavior is used (it searches sys.argv for -v).
+    """
+
+    import doctest
+
+    if verbosity is None:
+        verbosity = verbose
+    else:
+        verbosity = None
+
+    f, t = doctest.testmod(module, verbose=verbosity, optionflags=optionflags)
+    if f:
+        raise TestFailed("%d of %d doctests failed" % (f, t))
+    if verbose:
+        print('doctest (%s) ... %d tests with zero failures' %
+              (module.__name__, t))
+    return f, t
+
+
+#=======================================================================
+# Support for saving and restoring the imported modules.
+
+def print_warning(msg):
+    # bpo-39983: Print into sys.__stderr__ to display the warning even
+    # when sys.stderr is captured temporarily by a test
+    for line in msg.splitlines():
+        print(f"Warning -- {line}", file=sys.__stderr__, flush=True)
+
+
+# Flag used by saved_test_environment of test.libregrtest.save_env,
+# to check if a test modified the environment. The flag should be set to False
+# before running a new test.
+#
+# For example, threading_helper.threading_cleanup() sets the flag is the function fails
+# to cleanup threads.
+environment_altered = False
+
+def reap_children():
+    """Use this function at the end of test_main() whenever sub-processes
+    are started.  This will help ensure that no extra children (zombies)
+    stick around to hog resources and create problems when looking
+    for refleaks.
+    """
+    global environment_altered
+
+    # Need os.waitpid(-1, os.WNOHANG): Windows is not supported
+    if not (hasattr(os, 'waitpid') and hasattr(os, 'WNOHANG')):
+        return
+
+    # Reap all our dead child processes so we don't leave zombies around.
+    # These hog resources and might be causing some of the buildbots to die.
+    while True:
+        try:
+            # Read the exit status of any child process which already completed
+            pid, status = os.waitpid(-1, os.WNOHANG)
+        except OSError:
+            break
+
+        if pid == 0:
+            break
+
+        print_warning(f"reap_children() reaped child process {pid}")
+        environment_altered = True
+
+
+@contextlib.contextmanager
+def swap_attr(obj, attr, new_val):
+    """Temporary swap out an attribute with a new object.
+
+    Usage:
+        with swap_attr(obj, "attr", 5):
+            ...
+
+        This will set obj.attr to 5 for the duration of the with: block,
+        restoring the old value at the end of the block. If `attr` doesn't
+        exist on `obj`, it will be created and then deleted at the end of the
+        block.
+
+        The old value (or None if it doesn't exist) will be assigned to the
+        target of the "as" clause, if there is one.
+    """
+    if hasattr(obj, attr):
+        real_val = getattr(obj, attr)
+        setattr(obj, attr, new_val)
+        try:
+            yield real_val
+        finally:
+            setattr(obj, attr, real_val)
+    else:
+        setattr(obj, attr, new_val)
+        try:
+            yield
+        finally:
+            if hasattr(obj, attr):
+                delattr(obj, attr)
+
+@contextlib.contextmanager
+def swap_item(obj, item, new_val):
+    """Temporary swap out an item with a new object.
+
+    Usage:
+        with swap_item(obj, "item", 5):
+            ...
+
+        This will set obj["item"] to 5 for the duration of the with: block,
+        restoring the old value at the end of the block. If `item` doesn't
+        exist on `obj`, it will be created and then deleted at the end of the
+        block.
+
+        The old value (or None if it doesn't exist) will be assigned to the
+        target of the "as" clause, if there is one.
+    """
+    if item in obj:
+        real_val = obj[item]
+        obj[item] = new_val
+        try:
+            yield real_val
+        finally:
+            obj[item] = real_val
+    else:
+        obj[item] = new_val
+        try:
+            yield
+        finally:
+            if item in obj:
+                del obj[item]
+
+def args_from_interpreter_flags():
+    """Return a list of command-line arguments reproducing the current
+    settings in sys.flags and sys.warnoptions."""
+    import subprocess
+    return subprocess._args_from_interpreter_flags()
+
+def optim_args_from_interpreter_flags():
+    """Return a list of command-line arguments reproducing the current
+    optimization settings in sys.flags."""
+    import subprocess
+    return subprocess._optim_args_from_interpreter_flags()
+
+
+class Matcher(object):
+
+    _partial_matches = ('msg', 'message')
+
+    def matches(self, d, **kwargs):
+        """
+        Try to match a single dict with the supplied arguments.
+
+        Keys whose values are strings and which are in self._partial_matches
+        will be checked for partial (i.e. substring) matches. You can extend
+        this scheme to (for example) do regular expression matching, etc.
+        """
+        result = True
+        for k in kwargs:
+            v = kwargs[k]
+            dv = d.get(k)
+            if not self.match_value(k, dv, v):
+                result = False
+                break
+        return result
+
+    def match_value(self, k, dv, v):
+        """
+        Try to match a single stored value (dv) with a supplied value (v).
+        """
+        if type(v) != type(dv):
+            result = False
+        elif type(dv) is not str or k not in self._partial_matches:
+            result = (v == dv)
+        else:
+            result = dv.find(v) >= 0
+        return result
+
+
+_buggy_ucrt = None
+def skip_if_buggy_ucrt_strfptime(test):
+    """
+    Skip decorator for tests that use buggy strptime/strftime
+
+    If the UCRT bugs are present time.localtime().tm_zone will be
+    an empty string, otherwise we assume the UCRT bugs are fixed
+
+    See bpo-37552 [Windows] strptime/strftime return invalid
+    results with UCRT version 17763.615
+    """
+    import locale
+    global _buggy_ucrt
+    if _buggy_ucrt is None:
+        if(sys.platform == 'win32' and
+                locale.getdefaultlocale()[1]  == 'cp65001' and
+                time.localtime().tm_zone == ''):
+            _buggy_ucrt = True
+        else:
+            _buggy_ucrt = False
+    return unittest.skip("buggy MSVC UCRT strptime/strftime")(test) if _buggy_ucrt else test
+
+class PythonSymlink:
+    """Creates a symlink for the current Python executable"""
+    def __init__(self, link=None):
+        from .os_helper import TESTFN
+
+        self.link = link or os.path.abspath(TESTFN)
+        self._linked = []
+        self.real = os.path.realpath(sys.executable)
+        self._also_link = []
+
+        self._env = None
+
+        self._platform_specific()
+
+    if sys.platform == "win32":
+        def _platform_specific(self):
+            import glob
+            import _winapi
+
+            if os.path.lexists(self.real) and not os.path.exists(self.real):
+                # App symlink appears to not exist, but we want the
+                # real executable here anyway
+                self.real = _winapi.GetModuleFileName(0)
+
+            dll = _winapi.GetModuleFileName(sys.dllhandle)
+            src_dir = os.path.dirname(dll)
+            dest_dir = os.path.dirname(self.link)
+            self._also_link.append((
+                dll,
+                os.path.join(dest_dir, os.path.basename(dll))
+            ))
+            for runtime in glob.glob(os.path.join(glob.escape(src_dir), "vcruntime*.dll")):
+                self._also_link.append((
+                    runtime,
+                    os.path.join(dest_dir, os.path.basename(runtime))
+                ))
+
+            self._env = {k.upper(): os.getenv(k) for k in os.environ}
+            self._env["PYTHONHOME"] = os.path.dirname(self.real)
+            if sysconfig.is_python_build(True):
+                self._env["PYTHONPATH"] = os.path.dirname(os.__file__)
+    else:
+        def _platform_specific(self):
+            pass
+
+    def __enter__(self):
+        os.symlink(self.real, self.link)
+        self._linked.append(self.link)
+        for real, link in self._also_link:
+            os.symlink(real, link)
+            self._linked.append(link)
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        for link in self._linked:
+            try:
+                os.remove(link)
+            except IOError as ex:
+                if verbose:
+                    print("failed to clean up {}: {}".format(link, ex))
+
+    def _call(self, python, args, env, returncode):
+        import subprocess
+        cmd = [python, *args]
+        p = subprocess.Popen(cmd, stdout=subprocess.PIPE,
+                             stderr=subprocess.PIPE, env=env)
+        r = p.communicate()
+        if p.returncode != returncode:
+            if verbose:
+                print(repr(r[0]))
+                print(repr(r[1]), file=sys.stderr)
+            raise RuntimeError(
+                'unexpected return code: {0} (0x{0:08X})'.format(p.returncode))
+        return r
+
+    def call_real(self, *args, returncode=0):
+        return self._call(self.real, args, None, returncode)
+
+    def call_link(self, *args, returncode=0):
+        return self._call(self.link, args, self._env, returncode)
+
+
+def skip_if_pgo_task(test):
+    """Skip decorator for tests not run in (non-extended) PGO task"""
+    ok = not PGO or PGO_EXTENDED
+    msg = "Not run for (non-extended) PGO task"
+    return test if ok else unittest.skip(msg)(test)
+
+
+def detect_api_mismatch(ref_api, other_api, *, ignore=()):
+    """Returns the set of items in ref_api not in other_api, except for a
+    defined list of items to be ignored in this check.
+
+    By default this skips private attributes beginning with '_' but
+    includes all magic methods, i.e. those starting and ending in '__'.
+    """
+    missing_items = set(dir(ref_api)) - set(dir(other_api))
+    if ignore:
+        missing_items -= set(ignore)
+    missing_items = set(m for m in missing_items
+                        if not m.startswith('_') or m.endswith('__'))
+    return missing_items
+
+
+def check__all__(test_case, module, name_of_module=None, extra=(),
+                 not_exported=()):
+    """Assert that the __all__ variable of 'module' contains all public names.
+
+    The module's public names (its API) are detected automatically based on
+    whether they match the public name convention and were defined in
+    'module'.
+
+    The 'name_of_module' argument can specify (as a string or tuple thereof)
+    what module(s) an API could be defined in in order to be detected as a
+    public API. One case for this is when 'module' imports part of its public
+    API from other modules, possibly a C backend (like 'csv' and its '_csv').
+
+    The 'extra' argument can be a set of names that wouldn't otherwise be
+    automatically detected as "public", like objects without a proper
+    '__module__' attribute. If provided, it will be added to the
+    automatically detected ones.
+
+    The 'not_exported' argument can be a set of names that must not be treated
+    as part of the public API even though their names indicate otherwise.
+
+    Usage:
+        import bar
+        import foo
+        import unittest
+        from test import support
+
+        class MiscTestCase(unittest.TestCase):
+            def test__all__(self):
+                support.check__all__(self, foo)
+
+        class OtherTestCase(unittest.TestCase):
+            def test__all__(self):
+                extra = {'BAR_CONST', 'FOO_CONST'}
+                not_exported = {'baz'}  # Undocumented name.
+                # bar imports part of its API from _bar.
+                support.check__all__(self, bar, ('bar', '_bar'),
+                                     extra=extra, not_exported=not_exported)
+
+    """
+
+    if name_of_module is None:
+        name_of_module = (module.__name__, )
+    elif isinstance(name_of_module, str):
+        name_of_module = (name_of_module, )
+
+    expected = set(extra)
+
+    for name in dir(module):
+        if name.startswith('_') or name in not_exported:
+            continue
+        obj = getattr(module, name)
+        if (getattr(obj, '__module__', None) in name_of_module or
+                (not hasattr(obj, '__module__') and
+                 not isinstance(obj, types.ModuleType))):
+            expected.add(name)
+    test_case.assertCountEqual(module.__all__, expected)
+
+
+def suppress_msvcrt_asserts(verbose=False):
+    try:
+        import msvcrt
+    except ImportError:
+        return
+
+    msvcrt.SetErrorMode(msvcrt.SEM_FAILCRITICALERRORS
+                        | msvcrt.SEM_NOALIGNMENTFAULTEXCEPT
+                        | msvcrt.SEM_NOGPFAULTERRORBOX
+                        | msvcrt.SEM_NOOPENFILEERRORBOX)
+
+    # CrtSetReportMode() is only available in debug build
+    if hasattr(msvcrt, 'CrtSetReportMode'):
+        for m in [msvcrt.CRT_WARN, msvcrt.CRT_ERROR, msvcrt.CRT_ASSERT]:
+            if verbose:
+                msvcrt.CrtSetReportMode(m, msvcrt.CRTDBG_MODE_FILE)
+                msvcrt.CrtSetReportFile(m, msvcrt.CRTDBG_FILE_STDERR)
+            else:
+                msvcrt.CrtSetReportMode(m, 0)
+
+
+class SuppressCrashReport:
+    """Try to prevent a crash report from popping up.
+
+    On Windows, don't display the Windows Error Reporting dialog.  On UNIX,
+    disable the creation of coredump file.
+    """
+    old_value = None
+    old_modes = None
+
+    def __enter__(self):
+        """On Windows, disable Windows Error Reporting dialogs using
+        SetErrorMode() and CrtSetReportMode().
+
+        On UNIX, try to save the previous core file size limit, then set
+        soft limit to 0.
+        """
+        if sys.platform.startswith('win'):
+            # see http://msdn.microsoft.com/en-us/library/windows/desktop/ms680621.aspx
+            try:
+                import msvcrt
+            except ImportError:
+                return
+
+            self.old_value = msvcrt.GetErrorMode()
+
+            msvcrt.SetErrorMode(self.old_value | msvcrt.SEM_NOGPFAULTERRORBOX)
+
+            # bpo-23314: Suppress assert dialogs in debug builds.
+            # CrtSetReportMode() is only available in debug build.
+            if hasattr(msvcrt, 'CrtSetReportMode'):
+                self.old_modes = {}
+                for report_type in [msvcrt.CRT_WARN,
+                                    msvcrt.CRT_ERROR,
+                                    msvcrt.CRT_ASSERT]:
+                    old_mode = msvcrt.CrtSetReportMode(report_type,
+                            msvcrt.CRTDBG_MODE_FILE)
+                    old_file = msvcrt.CrtSetReportFile(report_type,
+                            msvcrt.CRTDBG_FILE_STDERR)
+                    self.old_modes[report_type] = old_mode, old_file
+
+        else:
+            try:
+                import resource
+                self.resource = resource
+            except ImportError:
+                self.resource = None
+            if self.resource is not None:
+                try:
+                    self.old_value = self.resource.getrlimit(self.resource.RLIMIT_CORE)
+                    self.resource.setrlimit(self.resource.RLIMIT_CORE,
+                                            (0, self.old_value[1]))
+                except (ValueError, OSError):
+                    pass
+
+            if sys.platform == 'darwin':
+                import subprocess
+                # Check if the 'Crash Reporter' on OSX was configured
+                # in 'Developer' mode and warn that it will get triggered
+                # when it is.
+                #
+                # This assumes that this context manager is used in tests
+                # that might trigger the next manager.
+                cmd = ['/usr/bin/defaults', 'read',
+                       'com.apple.CrashReporter', 'DialogType']
+                proc = subprocess.Popen(cmd,
+                                        stdout=subprocess.PIPE,
+                                        stderr=subprocess.PIPE)
+                with proc:
+                    stdout = proc.communicate()[0]
+                if stdout.strip() == b'developer':
+                    print("this test triggers the Crash Reporter, "
+                          "that is intentional", end='', flush=True)
+
+        return self
+
+    def __exit__(self, *ignore_exc):
+        """Restore Windows ErrorMode or core file behavior to initial value."""
+        if self.old_value is None:
+            return
+
+        if sys.platform.startswith('win'):
+            import msvcrt
+            msvcrt.SetErrorMode(self.old_value)
+
+            if self.old_modes:
+                for report_type, (old_mode, old_file) in self.old_modes.items():
+                    msvcrt.CrtSetReportMode(report_type, old_mode)
+                    msvcrt.CrtSetReportFile(report_type, old_file)
+        else:
+            if self.resource is not None:
+                try:
+                    self.resource.setrlimit(self.resource.RLIMIT_CORE, self.old_value)
+                except (ValueError, OSError):
+                    pass
+
+
+def patch(test_instance, object_to_patch, attr_name, new_value):
+    """Override 'object_to_patch'.'attr_name' with 'new_value'.
+
+    Also, add a cleanup procedure to 'test_instance' to restore
+    'object_to_patch' value for 'attr_name'.
+    The 'attr_name' should be a valid attribute for 'object_to_patch'.
+
+    """
+    # check that 'attr_name' is a real attribute for 'object_to_patch'
+    # will raise AttributeError if it does not exist
+    getattr(object_to_patch, attr_name)
+
+    # keep a copy of the old value
+    attr_is_local = False
+    try:
+        old_value = object_to_patch.__dict__[attr_name]
+    except (AttributeError, KeyError):
+        old_value = getattr(object_to_patch, attr_name, None)
+    else:
+        attr_is_local = True
+
+    # restore the value when the test is done
+    def cleanup():
+        if attr_is_local:
+            setattr(object_to_patch, attr_name, old_value)
+        else:
+            delattr(object_to_patch, attr_name)
+
+    test_instance.addCleanup(cleanup)
+
+    # actually override the attribute
+    setattr(object_to_patch, attr_name, new_value)
+
+
+@contextlib.contextmanager
+def patch_list(orig):
+    """Like unittest.mock.patch.dict, but for lists."""
+    try:
+        saved = orig[:]
+        yield
+    finally:
+        orig[:] = saved
+
+
+def run_in_subinterp(code):
+    """
+    Run code in a subinterpreter. Raise unittest.SkipTest if the tracemalloc
+    module is enabled.
+    """
+    # Issue #10915, #15751: PyGILState_*() functions don't work with
+    # sub-interpreters, the tracemalloc module uses these functions internally
+    try:
+        import tracemalloc
+    except ImportError:
+        pass
+    else:
+        if tracemalloc.is_tracing():
+            raise unittest.SkipTest("run_in_subinterp() cannot be used "
+                                     "if tracemalloc module is tracing "
+                                     "memory allocations")
+    import _testcapi
+    return _testcapi.run_in_subinterp(code)
+
+
+def check_free_after_iterating(test, iter, cls, args=()):
+    class A(cls):
+        def __del__(self):
+            nonlocal done
+            done = True
+            try:
+                next(it)
+            except StopIteration:
+                pass
+
+    done = False
+    it = iter(A(*args))
+    # Issue 26494: Shouldn't crash
+    test.assertRaises(StopIteration, next, it)
+    # The sequence should be deallocated just after the end of iterating
+    gc_collect()
+    test.assertTrue(done)
+
+
+def missing_compiler_executable(cmd_names=[]):
+    """Check if the compiler components used to build the interpreter exist.
+
+    Check for the existence of the compiler executables whose names are listed
+    in 'cmd_names' or all the compiler executables when 'cmd_names' is empty
+    and return the first missing executable or None when none is found
+    missing.
+
+    """
+    # TODO (PEP 632): alternate check without using distutils
+    from distutils import ccompiler, sysconfig, spawn, errors
+    compiler = ccompiler.new_compiler()
+    sysconfig.customize_compiler(compiler)
+    if compiler.compiler_type == "msvc":
+        # MSVC has no executables, so check whether initialization succeeds
+        try:
+            compiler.initialize()
+        except errors.DistutilsPlatformError:
+            return "msvc"
+    for name in compiler.executables:
+        if cmd_names and name not in cmd_names:
+            continue
+        cmd = getattr(compiler, name)
+        if cmd_names:
+            assert cmd is not None, \
+                    "the '%s' executable is not configured" % name
+        elif not cmd:
+            continue
+        if spawn.find_executable(cmd[0]) is None:
+            return cmd[0]
+
+
+_is_android_emulator = None
+def setswitchinterval(interval):
+    # Setting a very low gil interval on the Android emulator causes python
+    # to hang (issue #26939).
+    minimum_interval = 1e-5
+    if is_android and interval < minimum_interval:
+        global _is_android_emulator
+        if _is_android_emulator is None:
+            import subprocess
+            _is_android_emulator = (subprocess.check_output(
+                               ['getprop', 'ro.kernel.qemu']).strip() == b'1')
+        if _is_android_emulator:
+            interval = minimum_interval
+    return sys.setswitchinterval(interval)
+
+
+@contextlib.contextmanager
+def disable_faulthandler():
+    import faulthandler
+
+    # use sys.__stderr__ instead of sys.stderr, since regrtest replaces
+    # sys.stderr with a StringIO which has no file descriptor when a test
+    # is run with -W/--verbose3.
+    fd = sys.__stderr__.fileno()
+
+    is_enabled = faulthandler.is_enabled()
+    try:
+        faulthandler.disable()
+        yield
+    finally:
+        if is_enabled:
+            faulthandler.enable(file=fd, all_threads=True)
+
+
+class SaveSignals:
+    """
+    Save and restore signal handlers.
+
+    This class is only able to save/restore signal handlers registered
+    by the Python signal module: see bpo-13285 for "external" signal
+    handlers.
+    """
+
+    def __init__(self):
+        import signal
+        self.signal = signal
+        self.signals = signal.valid_signals()
+        # SIGKILL and SIGSTOP signals cannot be ignored nor caught
+        for signame in ('SIGKILL', 'SIGSTOP'):
+            try:
+                signum = getattr(signal, signame)
+            except AttributeError:
+                continue
+            self.signals.remove(signum)
+        self.handlers = {}
+
+    def save(self):
+        for signum in self.signals:
+            handler = self.signal.getsignal(signum)
+            if handler is None:
+                # getsignal() returns None if a signal handler was not
+                # registered by the Python signal module,
+                # and the handler is not SIG_DFL nor SIG_IGN.
+                #
+                # Ignore the signal: we cannot restore the handler.
+                continue
+            self.handlers[signum] = handler
+
+    def restore(self):
+        for signum, handler in self.handlers.items():
+            self.signal.signal(signum, handler)
+
+
+def with_pymalloc():
+    import _testcapi
+    return _testcapi.WITH_PYMALLOC
+
+
+class _ALWAYS_EQ:
+    """
+    Object that is equal to anything.
+    """
+    def __eq__(self, other):
+        return True
+    def __ne__(self, other):
+        return False
+
+ALWAYS_EQ = _ALWAYS_EQ()
+
+class _NEVER_EQ:
+    """
+    Object that is not equal to anything.
+    """
+    def __eq__(self, other):
+        return False
+    def __ne__(self, other):
+        return True
+    def __hash__(self):
+        return 1
+
+NEVER_EQ = _NEVER_EQ()
+
+@functools.total_ordering
+class _LARGEST:
+    """
+    Object that is greater than anything (except itself).
+    """
+    def __eq__(self, other):
+        return isinstance(other, _LARGEST)
+    def __lt__(self, other):
+        return False
+
+LARGEST = _LARGEST()
+
+@functools.total_ordering
+class _SMALLEST:
+    """
+    Object that is less than anything (except itself).
+    """
+    def __eq__(self, other):
+        return isinstance(other, _SMALLEST)
+    def __gt__(self, other):
+        return False
+
+SMALLEST = _SMALLEST()
+
+def maybe_get_event_loop_policy():
+    """Return the global event loop policy if one is set, else return None."""
+    import asyncio.events
+    return asyncio.events._event_loop_policy
+
+# Helpers for testing hashing.
+NHASHBITS = sys.hash_info.width # number of bits in hash() result
+assert NHASHBITS in (32, 64)
+
+# Return mean and sdev of number of collisions when tossing nballs balls
+# uniformly at random into nbins bins.  By definition, the number of
+# collisions is the number of balls minus the number of occupied bins at
+# the end.
+def collision_stats(nbins, nballs):
+    n, k = nbins, nballs
+    # prob a bin empty after k trials = (1 - 1/n)**k
+    # mean # empty is then n * (1 - 1/n)**k
+    # so mean # occupied is n - n * (1 - 1/n)**k
+    # so collisions = k - (n - n*(1 - 1/n)**k)
+    #
+    # For the variance:
+    # n*(n-1)*(1-2/n)**k + meanempty - meanempty**2 =
+    # n*(n-1)*(1-2/n)**k + meanempty * (1 - meanempty)
+    #
+    # Massive cancellation occurs, and, e.g., for a 64-bit hash code
+    # 1-1/2**64 rounds uselessly to 1.0.  Rather than make heroic (and
+    # error-prone) efforts to rework the naive formulas to avoid those,
+    # we use the `decimal` module to get plenty of extra precision.
+    #
+    # Note:  the exact values are straightforward to compute with
+    # rationals, but in context that's unbearably slow, requiring
+    # multi-million bit arithmetic.
+    import decimal
+    with decimal.localcontext() as ctx:
+        bits = n.bit_length() * 2  # bits in n**2
+        # At least that many bits will likely cancel out.
+        # Use that many decimal digits instead.
+        ctx.prec = max(bits, 30)
+        dn = decimal.Decimal(n)
+        p1empty = ((dn - 1) / dn) ** k
+        meanempty = n * p1empty
+        occupied = n - meanempty
+        collisions = k - occupied
+        var = dn*(dn-1)*((dn-2)/dn)**k + meanempty * (1 - meanempty)
+        return float(collisions), float(var.sqrt())
+
+
+class catch_unraisable_exception:
+    """
+    Context manager catching unraisable exception using sys.unraisablehook.
+
+    Storing the exception value (cm.unraisable.exc_value) creates a reference
+    cycle. The reference cycle is broken explicitly when the context manager
+    exits.
+
+    Storing the object (cm.unraisable.object) can resurrect it if it is set to
+    an object which is being finalized. Exiting the context manager clears the
+    stored object.
+
+    Usage:
+
+        with support.catch_unraisable_exception() as cm:
+            # code creating an "unraisable exception"
+            ...
+
+            # check the unraisable exception: use cm.unraisable
+            ...
+
+        # cm.unraisable attribute no longer exists at this point
+        # (to break a reference cycle)
+    """
+
+    def __init__(self):
+        self.unraisable = None
+        self._old_hook = None
+
+    def _hook(self, unraisable):
+        # Storing unraisable.object can resurrect an object which is being
+        # finalized. Storing unraisable.exc_value creates a reference cycle.
+        self.unraisable = unraisable
+
+    def __enter__(self):
+        self._old_hook = sys.unraisablehook
+        sys.unraisablehook = self._hook
+        return self
+
+    def __exit__(self, *exc_info):
+        sys.unraisablehook = self._old_hook
+        del self.unraisable
+
+
+def wait_process(pid, *, exitcode, timeout=None):
+    """
+    Wait until process pid completes and check that the process exit code is
+    exitcode.
+
+    Raise an AssertionError if the process exit code is not equal to exitcode.
+
+    If the process runs longer than timeout seconds (LONG_TIMEOUT by default),
+    kill the process (if signal.SIGKILL is available) and raise an
+    AssertionError. The timeout feature is not available on Windows.
+    """
+    if os.name != "nt":
+        import signal
+
+        if timeout is None:
+            timeout = LONG_TIMEOUT
+        t0 = time.monotonic()
+        sleep = 0.001
+        max_sleep = 0.1
+        while True:
+            pid2, status = os.waitpid(pid, os.WNOHANG)
+            if pid2 != 0:
+                break
+            # process is still running
+
+            dt = time.monotonic() - t0
+            if dt > timeout:
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                    os.waitpid(pid, 0)
+                except OSError:
+                    # Ignore errors like ChildProcessError or PermissionError
+                    pass
+
+                raise AssertionError(f"process {pid} is still running "
+                                     f"after {dt:.1f} seconds")
+
+            sleep = min(sleep * 2, max_sleep)
+            time.sleep(sleep)
+    else:
+        # Windows implementation
+        pid2, status = os.waitpid(pid, 0)
+
+    exitcode2 = os.waitstatus_to_exitcode(status)
+    if exitcode2 != exitcode:
+        raise AssertionError(f"process {pid} exited with code {exitcode2}, "
+                             f"but exit code {exitcode} is expected")
+
+    # sanity check: it should not fail in practice
+    if pid2 != pid:
+        raise AssertionError(f"pid {pid2} != pid {pid}")
+
+def skip_if_broken_multiprocessing_synchronize():
+    """
+    Skip tests if the multiprocessing.synchronize module is missing, if there
+    is no available semaphore implementation, or if creating a lock raises an
+    OSError (on Linux only).
+    """
+    from .import_helper import import_module
+
+    # Skip tests if the _multiprocessing extension is missing.
+    import_module('_multiprocessing')
+
+    # Skip tests if there is no available semaphore implementation:
+    # multiprocessing.synchronize requires _multiprocessing.SemLock.
+    synchronize = import_module('multiprocessing.synchronize')
+
+    if sys.platform == "linux":
+        try:
+            # bpo-38377: On Linux, creating a semaphore fails with OSError
+            # if the current user does not have the permission to create
+            # a file in /dev/shm/ directory.
+            synchronize.Lock(ctx=None)
+        except OSError as exc:
+            raise unittest.SkipTest(f"broken multiprocessing SemLock: {exc!r}")
+
+
+@contextlib.contextmanager
+def infinite_recursion(max_depth=75):
+    original_depth = sys.getrecursionlimit()
+    try:
+        sys.setrecursionlimit(max_depth)
+        yield
+    finally:
+        sys.setrecursionlimit(original_depth)
+
+
+def check_disallow_instantiation(testcase, tp, *args, **kwds):
+    """
+    Check that given type cannot be instantiated using *args and **kwds.
+
+    See bpo-43916: Add Py_TPFLAGS_DISALLOW_INSTANTIATION type flag.
+    """
+    mod = tp.__module__
+    name = tp.__name__
+    if mod != 'builtins':
+        qualname = f"{mod}.{name}"
+    else:
+        qualname = f"{name}"
+    msg = f"cannot create '{re.escape(qualname)}' instances"
+    testcase.assertRaisesRegex(TypeError, msg, tp, *args, **kwds)
+
+
+def ignore_deprecations_from(module: str, *, like: str) -> object:
+    token = object()
+    warnings.filterwarnings(
+        "ignore",
+        category=DeprecationWarning,
+        module=module,
+        message=like + fr"(?#support{id(token)})",
+    )
+    return token
+
+
+def clear_ignored_deprecations(*tokens: object) -> None:
+    if not tokens:
+        raise ValueError("Provide token or tokens returned by ignore_deprecations_from")
+
+    new_filters = []
+    endswith = tuple(rf"(?#support{id(token)})" for token in tokens)
+    for action, message, category, module, lineno in warnings.filters:
+        if action == "ignore" and category is DeprecationWarning:
+            if isinstance(message, re.Pattern):
+                msg = message.pattern
+            else:
+                msg = message or ""
+            if msg.endswith(endswith):
+                continue
+        new_filters.append((action, message, category, module, lineno))
+    if warnings.filters != new_filters:
+        warnings.filters[:] = new_filters
+        warnings._filters_mutated()
+
+
+@contextlib.contextmanager
+def adjust_int_max_str_digits(max_digits):
+    """Temporarily change the integer string conversion length limit."""
+    current = sys.get_int_max_str_digits()
+    try:
+        sys.set_int_max_str_digits(max_digits)
+        yield
+    finally:
+        sys.set_int_max_str_digits(current)
+
+
+def control_characters_c0() -> list[str]:
+    """Returns a list of C0 control characters as strings.
+    C0 control characters defined as the byte range 0x00-0x1F, and 0x7F.
+    """
+    return [chr(c) for c in range(0x00, 0x20)] + ["\x7F"]

miniconda3/envs/ladir/lib/python3.10/test/support/bytecode_helper.py

@@ -0,0 +1,42 @@
+"""bytecode_helper - support tools for testing correct bytecode generation"""
+
+import unittest
+import dis
+import io
+
+_UNSPECIFIED = object()
+
+class BytecodeTestCase(unittest.TestCase):
+    """Custom assertion methods for inspecting bytecode."""
+
+    def get_disassembly_as_string(self, co):
+        s = io.StringIO()
+        dis.dis(co, file=s)
+        return s.getvalue()
+
+    def assertInBytecode(self, x, opname, argval=_UNSPECIFIED):
+        """Returns instr if opname is found, otherwise throws AssertionError"""
+        for instr in dis.get_instructions(x):
+            if instr.opname == opname:
+                if argval is _UNSPECIFIED or instr.argval == argval:
+                    return instr
+        disassembly = self.get_disassembly_as_string(x)
+        if argval is _UNSPECIFIED:
+            msg = '%s not found in bytecode:\n%s' % (opname, disassembly)
+        else:
+            msg = '(%s,%r) not found in bytecode:\n%s'
+            msg = msg % (opname, argval, disassembly)
+        self.fail(msg)
+
+    def assertNotInBytecode(self, x, opname, argval=_UNSPECIFIED):
+        """Throws AssertionError if opname is found"""
+        for instr in dis.get_instructions(x):
+            if instr.opname == opname:
+                disassembly = self.get_disassembly_as_string(x)
+                if argval is _UNSPECIFIED:
+                    msg = '%s occurs in bytecode:\n%s' % (opname, disassembly)
+                    self.fail(msg)
+                elif instr.argval == argval:
+                    msg = '(%s,%r) occurs in bytecode:\n%s'
+                    msg = msg % (opname, argval, disassembly)
+                    self.fail(msg)

miniconda3/envs/ladir/lib/python3.10/test/support/hashlib_helper.py

@@ -0,0 +1,51 @@
+import functools
+import hashlib
+import unittest
+
+try:
+    import _hashlib
+except ImportError:
+    _hashlib = None
+
+
+def requires_hashdigest(digestname, openssl=None, usedforsecurity=True):
+    """Decorator raising SkipTest if a hashing algorithm is not available
+
+    The hashing algorithm could be missing or blocked by a strict crypto
+    policy.
+
+    If 'openssl' is True, then the decorator checks that OpenSSL provides
+    the algorithm. Otherwise the check falls back to built-in
+    implementations. The usedforsecurity flag is passed to the constructor.
+
+    ValueError: [digital envelope routines: EVP_DigestInit_ex] disabled for FIPS
+    ValueError: unsupported hash type md4
+    """
+    def decorator(func_or_class):
+        if isinstance(func_or_class, type):
+            setUpClass = func_or_class.__dict__.get('setUpClass')
+            if setUpClass is None:
+                def setUpClass(cls):
+                    super(func_or_class, cls).setUpClass()
+                setUpClass.__qualname__ = func_or_class.__qualname__ + '.setUpClass'
+                setUpClass.__module__ = func_or_class.__module__
+            else:
+                setUpClass = setUpClass.__func__
+            setUpClass = classmethod(decorator(setUpClass))
+            func_or_class.setUpClass = setUpClass
+            return func_or_class
+
+        @functools.wraps(func_or_class)
+        def wrapper(*args, **kwargs):
+            try:
+                if openssl and _hashlib is not None:
+                    _hashlib.new(digestname, usedforsecurity=usedforsecurity)
+                else:
+                    hashlib.new(digestname, usedforsecurity=usedforsecurity)
+            except ValueError:
+                raise unittest.SkipTest(
+                    f"hash digest '{digestname}' is not available."
+                )
+            return func_or_class(*args, **kwargs)
+        return wrapper
+    return decorator

miniconda3/envs/ladir/lib/python3.10/test/support/import_helper.py

@@ -0,0 +1,220 @@
+import contextlib
+import importlib
+import importlib.util
+import os
+import shutil
+import sys
+import unittest
+import warnings
+
+from .os_helper import unlink
+
+
+@contextlib.contextmanager
+def _ignore_deprecated_imports(ignore=True):
+    """Context manager to suppress package and module deprecation
+    warnings when importing them.
+
+    If ignore is False, this context manager has no effect.
+    """
+    if ignore:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", ".+ (module|package)",
+                                    DeprecationWarning)
+            yield
+    else:
+        yield
+
+
+def unload(name):
+    try:
+        del sys.modules[name]
+    except KeyError:
+        pass
+
+
+def forget(modname):
+    """'Forget' a module was ever imported.
+
+    This removes the module from sys.modules and deletes any PEP 3147/488 or
+    legacy .pyc files.
+    """
+    unload(modname)
+    for dirname in sys.path:
+        source = os.path.join(dirname, modname + '.py')
+        # It doesn't matter if they exist or not, unlink all possible
+        # combinations of PEP 3147/488 and legacy pyc files.
+        unlink(source + 'c')
+        for opt in ('', 1, 2):
+            unlink(importlib.util.cache_from_source(source, optimization=opt))
+
+
+def make_legacy_pyc(source):
+    """Move a PEP 3147/488 pyc file to its legacy pyc location.
+
+    :param source: The file system path to the source file.  The source file
+        does not need to exist, however the PEP 3147/488 pyc file must exist.
+    :return: The file system path to the legacy pyc file.
+    """
+    pyc_file = importlib.util.cache_from_source(source)
+    up_one = os.path.dirname(os.path.abspath(source))
+    legacy_pyc = os.path.join(up_one, source + 'c')
+    shutil.move(pyc_file, legacy_pyc)
+    return legacy_pyc
+
+
+def import_module(name, deprecated=False, *, required_on=()):
+    """Import and return the module to be tested, raising SkipTest if
+    it is not available.
+
+    If deprecated is True, any module or package deprecation messages
+    will be suppressed. If a module is required on a platform but optional for
+    others, set required_on to an iterable of platform prefixes which will be
+    compared against sys.platform.
+    """
+    with _ignore_deprecated_imports(deprecated):
+        try:
+            return importlib.import_module(name)
+        except ImportError as msg:
+            if sys.platform.startswith(tuple(required_on)):
+                raise
+            raise unittest.SkipTest(str(msg))
+
+
+def _save_and_remove_modules(names):
+    orig_modules = {}
+    prefixes = tuple(name + '.' for name in names)
+    for modname in list(sys.modules):
+        if modname in names or modname.startswith(prefixes):
+            orig_modules[modname] = sys.modules.pop(modname)
+    return orig_modules
+
+
+def import_fresh_module(name, fresh=(), blocked=(), deprecated=False):
+    """Import and return a module, deliberately bypassing sys.modules.
+
+    This function imports and returns a fresh copy of the named Python module
+    by removing the named module from sys.modules before doing the import.
+    Note that unlike reload, the original module is not affected by
+    this operation.
+
+    *fresh* is an iterable of additional module names that are also removed
+    from the sys.modules cache before doing the import. If one of these
+    modules can't be imported, None is returned.
+
+    *blocked* is an iterable of module names that are replaced with None
+    in the module cache during the import to ensure that attempts to import
+    them raise ImportError.
+
+    The named module and any modules named in the *fresh* and *blocked*
+    parameters are saved before starting the import and then reinserted into
+    sys.modules when the fresh import is complete.
+
+    Module and package deprecation messages are suppressed during this import
+    if *deprecated* is True.
+
+    This function will raise ImportError if the named module cannot be
+    imported.
+    """
+    # NOTE: test_heapq, test_json and test_warnings include extra sanity checks
+    # to make sure that this utility function is working as expected
+    with _ignore_deprecated_imports(deprecated):
+        # Keep track of modules saved for later restoration as well
+        # as those which just need a blocking entry removed
+        fresh = list(fresh)
+        blocked = list(blocked)
+        names = {name, *fresh, *blocked}
+        orig_modules = _save_and_remove_modules(names)
+        for modname in blocked:
+            sys.modules[modname] = None
+
+        try:
+            # Return None when one of the "fresh" modules can not be imported.
+            try:
+                for modname in fresh:
+                    __import__(modname)
+            except ImportError:
+                return None
+            return importlib.import_module(name)
+        finally:
+            _save_and_remove_modules(names)
+            sys.modules.update(orig_modules)
+
+
+class CleanImport(object):
+    """Context manager to force import to return a new module reference.
+
+    This is useful for testing module-level behaviours, such as
+    the emission of a DeprecationWarning on import.
+
+    Use like this:
+
+        with CleanImport("foo"):
+            importlib.import_module("foo") # new reference
+    """
+
+    def __init__(self, *module_names):
+        self.original_modules = sys.modules.copy()
+        for module_name in module_names:
+            if module_name in sys.modules:
+                module = sys.modules[module_name]
+                # It is possible that module_name is just an alias for
+                # another module (e.g. stub for modules renamed in 3.x).
+                # In that case, we also need delete the real module to clear
+                # the import cache.
+                if module.__name__ != module_name:
+                    del sys.modules[module.__name__]
+                del sys.modules[module_name]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *ignore_exc):
+        sys.modules.update(self.original_modules)
+
+
+class DirsOnSysPath(object):
+    """Context manager to temporarily add directories to sys.path.
+
+    This makes a copy of sys.path, appends any directories given
+    as positional arguments, then reverts sys.path to the copied
+    settings when the context ends.
+
+    Note that *all* sys.path modifications in the body of the
+    context manager, including replacement of the object,
+    will be reverted at the end of the block.
+    """
+
+    def __init__(self, *paths):
+        self.original_value = sys.path[:]
+        self.original_object = sys.path
+        sys.path.extend(paths)
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *ignore_exc):
+        sys.path = self.original_object
+        sys.path[:] = self.original_value
+
+
+def modules_setup():
+    return sys.modules.copy(),
+
+
+def modules_cleanup(oldmodules):
+    # Encoders/decoders are registered permanently within the internal
+    # codec cache. If we destroy the corresponding modules their
+    # globals will be set to None which will trip up the cached functions.
+    encodings = [(k, v) for k, v in sys.modules.items()
+                 if k.startswith('encodings.')]
+    sys.modules.clear()
+    sys.modules.update(encodings)
+    # XXX: This kind of problem can affect more than just encodings.
+    # In particular extension modules (such as _ssl) don't cope
+    # with reloading properly. Really, test modules should be cleaning
+    # out the test specific modules they know they added (ala test_runpy)
+    # rather than relying on this function (as test_importhooks and test_pkg
+    # do currently). Implicitly imported *real* modules should be left alone
+    # (see issue 10556).
+    sys.modules.update(oldmodules)

miniconda3/envs/ladir/lib/python3.10/test/support/interpreters.py

@@ -0,0 +1,197 @@
+"""Subinterpreters High Level Module."""
+
+import time
+import _xxsubinterpreters as _interpreters
+
+# aliases:
+from _xxsubinterpreters import (
+    ChannelError, ChannelNotFoundError, ChannelEmptyError,
+    is_shareable,
+)
+
+
+__all__ = [
+    'Interpreter', 'get_current', 'get_main', 'create', 'list_all',
+    'SendChannel', 'RecvChannel',
+    'create_channel', 'list_all_channels', 'is_shareable',
+    'ChannelError', 'ChannelNotFoundError',
+    'ChannelEmptyError',
+    ]
+
+
+def create(*, isolated=True):
+    """Return a new (idle) Python interpreter."""
+    id = _interpreters.create(isolated=isolated)
+    return Interpreter(id, isolated=isolated)
+
+
+def list_all():
+    """Return all existing interpreters."""
+    return [Interpreter(id) for id in _interpreters.list_all()]
+
+
+def get_current():
+    """Return the currently running interpreter."""
+    id = _interpreters.get_current()
+    return Interpreter(id)
+
+
+def get_main():
+    """Return the main interpreter."""
+    id = _interpreters.get_main()
+    return Interpreter(id)
+
+
+class Interpreter:
+    """A single Python interpreter."""
+
+    def __init__(self, id, *, isolated=None):
+        if not isinstance(id, (int, _interpreters.InterpreterID)):
+            raise TypeError(f'id must be an int, got {id!r}')
+        self._id = id
+        self._isolated = isolated
+
+    def __repr__(self):
+        data = dict(id=int(self._id), isolated=self._isolated)
+        kwargs = (f'{k}={v!r}' for k, v in data.items())
+        return f'{type(self).__name__}({", ".join(kwargs)})'
+
+    def __hash__(self):
+        return hash(self._id)
+
+    def __eq__(self, other):
+        if not isinstance(other, Interpreter):
+            return NotImplemented
+        else:
+            return other._id == self._id
+
+    @property
+    def id(self):
+        return self._id
+
+    @property
+    def isolated(self):
+        if self._isolated is None:
+            # XXX The low-level function has not been added yet.
+            # See bpo-....
+            self._isolated = _interpreters.is_isolated(self._id)
+        return self._isolated
+
+    def is_running(self):
+        """Return whether or not the identified interpreter is running."""
+        return _interpreters.is_running(self._id)
+
+    def close(self):
+        """Finalize and destroy the interpreter.
+
+        Attempting to destroy the current interpreter results
+        in a RuntimeError.
+        """
+        return _interpreters.destroy(self._id)
+
+    def run(self, src_str, /, *, channels=None):
+        """Run the given source code in the interpreter.
+
+        This blocks the current Python thread until done.
+        """
+        _interpreters.run_string(self._id, src_str, channels)
+
+
+def create_channel():
+    """Return (recv, send) for a new cross-interpreter channel.
+
+    The channel may be used to pass data safely between interpreters.
+    """
+    cid = _interpreters.channel_create()
+    recv, send = RecvChannel(cid), SendChannel(cid)
+    return recv, send
+
+
+def list_all_channels():
+    """Return a list of (recv, send) for all open channels."""
+    return [(RecvChannel(cid), SendChannel(cid))
+            for cid in _interpreters.channel_list_all()]
+
+
+class _ChannelEnd:
+    """The base class for RecvChannel and SendChannel."""
+
+    def __init__(self, id):
+        if not isinstance(id, (int, _interpreters.ChannelID)):
+            raise TypeError(f'id must be an int, got {id!r}')
+        self._id = id
+
+    def __repr__(self):
+        return f'{type(self).__name__}(id={int(self._id)})'
+
+    def __hash__(self):
+        return hash(self._id)
+
+    def __eq__(self, other):
+        if isinstance(self, RecvChannel):
+            if not isinstance(other, RecvChannel):
+                return NotImplemented
+        elif not isinstance(other, SendChannel):
+            return NotImplemented
+        return other._id == self._id
+
+    @property
+    def id(self):
+        return self._id
+
+
+_NOT_SET = object()
+
+
+class RecvChannel(_ChannelEnd):
+    """The receiving end of a cross-interpreter channel."""
+
+    def recv(self, *, _sentinel=object(), _delay=10 / 1000):  # 10 milliseconds
+        """Return the next object from the channel.
+
+        This blocks until an object has been sent, if none have been
+        sent already.
+        """
+        obj = _interpreters.channel_recv(self._id, _sentinel)
+        while obj is _sentinel:
+            time.sleep(_delay)
+            obj = _interpreters.channel_recv(self._id, _sentinel)
+        return obj
+
+    def recv_nowait(self, default=_NOT_SET):
+        """Return the next object from the channel.
+
+        If none have been sent then return the default if one
+        is provided or fail with ChannelEmptyError.  Otherwise this
+        is the same as recv().
+        """
+        if default is _NOT_SET:
+            return _interpreters.channel_recv(self._id)
+        else:
+            return _interpreters.channel_recv(self._id, default)
+
+
+class SendChannel(_ChannelEnd):
+    """The sending end of a cross-interpreter channel."""
+
+    def send(self, obj):
+        """Send the object (i.e. its data) to the channel's receiving end.
+
+        This blocks until the object is received.
+        """
+        _interpreters.channel_send(self._id, obj)
+        # XXX We are missing a low-level channel_send_wait().
+        # See bpo-32604 and gh-19829.
+        # Until that shows up we fake it:
+        time.sleep(2)
+
+    def send_nowait(self, obj):
+        """Send the object to the channel's receiving end.
+
+        If the object is immediately received then return True
+        (else False).  Otherwise this is the same as send().
+        """
+        # XXX Note that at the moment channel_send() only ever returns
+        # None.  This should be fixed when channel_send_wait() is added.
+        # See bpo-32604 and gh-19829.
+        return _interpreters.channel_send(self._id, obj)

miniconda3/envs/ladir/lib/python3.10/test/support/logging_helper.py

@@ -0,0 +1,29 @@
+import logging.handlers
+
+class TestHandler(logging.handlers.BufferingHandler):
+    def __init__(self, matcher):
+        # BufferingHandler takes a "capacity" argument
+        # so as to know when to flush. As we're overriding
+        # shouldFlush anyway, we can set a capacity of zero.
+        # You can call flush() manually to clear out the
+        # buffer.
+        logging.handlers.BufferingHandler.__init__(self, 0)
+        self.matcher = matcher
+
+    def shouldFlush(self):
+        return False
+
+    def emit(self, record):
+        self.format(record)
+        self.buffer.append(record.__dict__)
+
+    def matches(self, **kwargs):
+        """
+        Look for a saved dict whose keys/values match the supplied arguments.
+        """
+        result = False
+        for d in self.buffer:
+            if self.matcher.matches(d, **kwargs):
+                result = True
+                break
+        return result

miniconda3/envs/ladir/lib/python3.10/test/support/os_helper.py

@@ -0,0 +1,623 @@
+import collections.abc
+import contextlib
+import errno
+import os
+import re
+import stat
+import sys
+import time
+import unittest
+import warnings
+
+
+# Filename used for testing
+if os.name == 'java':
+    # Jython disallows @ in module names
+    TESTFN_ASCII = '$test'
+else:
+    TESTFN_ASCII = '@test'
+
+# Disambiguate TESTFN for parallel testing, while letting it remain a valid
+# module name.
+TESTFN_ASCII = "{}_{}_tmp".format(TESTFN_ASCII, os.getpid())
+
+# TESTFN_UNICODE is a non-ascii filename
+TESTFN_UNICODE = TESTFN_ASCII + "-\xe0\xf2\u0258\u0141\u011f"
+if sys.platform == 'darwin':
+    # In Mac OS X's VFS API file names are, by definition, canonically
+    # decomposed Unicode, encoded using UTF-8. See QA1173:
+    # http://developer.apple.com/mac/library/qa/qa2001/qa1173.html
+    import unicodedata
+    TESTFN_UNICODE = unicodedata.normalize('NFD', TESTFN_UNICODE)
+
+# TESTFN_UNENCODABLE is a filename (str type) that should *not* be able to be
+# encoded by the filesystem encoding (in strict mode). It can be None if we
+# cannot generate such filename.
+TESTFN_UNENCODABLE = None
+if os.name == 'nt':
+    # skip win32s (0) or Windows 9x/ME (1)
+    if sys.getwindowsversion().platform >= 2:
+        # Different kinds of characters from various languages to minimize the
+        # probability that the whole name is encodable to MBCS (issue #9819)
+        TESTFN_UNENCODABLE = TESTFN_ASCII + "-\u5171\u0141\u2661\u0363\uDC80"
+        try:
+            TESTFN_UNENCODABLE.encode(sys.getfilesystemencoding())
+        except UnicodeEncodeError:
+            pass
+        else:
+            print('WARNING: The filename %r CAN be encoded by the filesystem '
+                  'encoding (%s). Unicode filename tests may not be effective'
+                  % (TESTFN_UNENCODABLE, sys.getfilesystemencoding()))
+            TESTFN_UNENCODABLE = None
+# Mac OS X denies unencodable filenames (invalid utf-8)
+elif sys.platform != 'darwin':
+    try:
+        # ascii and utf-8 cannot encode the byte 0xff
+        b'\xff'.decode(sys.getfilesystemencoding())
+    except UnicodeDecodeError:
+        # 0xff will be encoded using the surrogate character u+DCFF
+        TESTFN_UNENCODABLE = TESTFN_ASCII \
+            + b'-\xff'.decode(sys.getfilesystemencoding(), 'surrogateescape')
+    else:
+        # File system encoding (eg. ISO-8859-* encodings) can encode
+        # the byte 0xff. Skip some unicode filename tests.
+        pass
+
+# FS_NONASCII: non-ASCII character encodable by os.fsencode(),
+# or an empty string if there is no such character.
+FS_NONASCII = ''
+for character in (
+    # First try printable and common characters to have a readable filename.
+    # For each character, the encoding list are just example of encodings able
+    # to encode the character (the list is not exhaustive).
+
+    # U+00E6 (Latin Small Letter Ae): cp1252, iso-8859-1
+    '\u00E6',
+    # U+0130 (Latin Capital Letter I With Dot Above): cp1254, iso8859_3
+    '\u0130',
+    # U+0141 (Latin Capital Letter L With Stroke): cp1250, cp1257
+    '\u0141',
+    # U+03C6 (Greek Small Letter Phi): cp1253
+    '\u03C6',
+    # U+041A (Cyrillic Capital Letter Ka): cp1251
+    '\u041A',
+    # U+05D0 (Hebrew Letter Alef): Encodable to cp424
+    '\u05D0',
+    # U+060C (Arabic Comma): cp864, cp1006, iso8859_6, mac_arabic
+    '\u060C',
+    # U+062A (Arabic Letter Teh): cp720
+    '\u062A',
+    # U+0E01 (Thai Character Ko Kai): cp874
+    '\u0E01',
+
+    # Then try more "special" characters. "special" because they may be
+    # interpreted or displayed differently depending on the exact locale
+    # encoding and the font.
+
+    # U+00A0 (No-Break Space)
+    '\u00A0',
+    # U+20AC (Euro Sign)
+    '\u20AC',
+):
+    try:
+        # If Python is set up to use the legacy 'mbcs' in Windows,
+        # 'replace' error mode is used, and encode() returns b'?'
+        # for characters missing in the ANSI codepage
+        if os.fsdecode(os.fsencode(character)) != character:
+            raise UnicodeError
+    except UnicodeError:
+        pass
+    else:
+        FS_NONASCII = character
+        break
+
+# Save the initial cwd
+SAVEDCWD = os.getcwd()
+
+# TESTFN_UNDECODABLE is a filename (bytes type) that should *not* be able to be
+# decoded from the filesystem encoding (in strict mode). It can be None if we
+# cannot generate such filename (ex: the latin1 encoding can decode any byte
+# sequence). On UNIX, TESTFN_UNDECODABLE can be decoded by os.fsdecode() thanks
+# to the surrogateescape error handler (PEP 383), but not from the filesystem
+# encoding in strict mode.
+TESTFN_UNDECODABLE = None
+for name in (
+    # b'\xff' is not decodable by os.fsdecode() with code page 932. Windows
+    # accepts it to create a file or a directory, or don't accept to enter to
+    # such directory (when the bytes name is used). So test b'\xe7' first:
+    # it is not decodable from cp932.
+    b'\xe7w\xf0',
+    # undecodable from ASCII, UTF-8
+    b'\xff',
+    # undecodable from iso8859-3, iso8859-6, iso8859-7, cp424, iso8859-8, cp856
+    # and cp857
+    b'\xae\xd5'
+    # undecodable from UTF-8 (UNIX and Mac OS X)
+    b'\xed\xb2\x80', b'\xed\xb4\x80',
+    # undecodable from shift_jis, cp869, cp874, cp932, cp1250, cp1251, cp1252,
+    # cp1253, cp1254, cp1255, cp1257, cp1258
+    b'\x81\x98',
+):
+    try:
+        name.decode(sys.getfilesystemencoding())
+    except UnicodeDecodeError:
+        TESTFN_UNDECODABLE = os.fsencode(TESTFN_ASCII) + name
+        break
+
+if FS_NONASCII:
+    TESTFN_NONASCII = TESTFN_ASCII + FS_NONASCII
+else:
+    TESTFN_NONASCII = None
+TESTFN = TESTFN_NONASCII or TESTFN_ASCII
+
+
+def make_bad_fd():
+    """
+    Create an invalid file descriptor by opening and closing a file and return
+    its fd.
+    """
+    file = open(TESTFN, "wb")
+    try:
+        return file.fileno()
+    finally:
+        file.close()
+        unlink(TESTFN)
+
+
+_can_symlink = None
+
+
+def can_symlink():
+    global _can_symlink
+    if _can_symlink is not None:
+        return _can_symlink
+    symlink_path = TESTFN + "can_symlink"
+    try:
+        os.symlink(TESTFN, symlink_path)
+        can = True
+    except (OSError, NotImplementedError, AttributeError):
+        can = False
+    else:
+        os.remove(symlink_path)
+    _can_symlink = can
+    return can
+
+
+def skip_unless_symlink(test):
+    """Skip decorator for tests that require functional symlink"""
+    ok = can_symlink()
+    msg = "Requires functional symlink implementation"
+    return test if ok else unittest.skip(msg)(test)
+
+
+_can_xattr = None
+
+
+def can_xattr():
+    import tempfile
+    global _can_xattr
+    if _can_xattr is not None:
+        return _can_xattr
+    if not hasattr(os, "setxattr"):
+        can = False
+    else:
+        import platform
+        tmp_dir = tempfile.mkdtemp()
+        tmp_fp, tmp_name = tempfile.mkstemp(dir=tmp_dir)
+        try:
+            with open(TESTFN, "wb") as fp:
+                try:
+                    # TESTFN & tempfile may use different file systems with
+                    # different capabilities
+                    os.setxattr(tmp_fp, b"user.test", b"")
+                    os.setxattr(tmp_name, b"trusted.foo", b"42")
+                    os.setxattr(fp.fileno(), b"user.test", b"")
+                    # Kernels < 2.6.39 don't respect setxattr flags.
+                    kernel_version = platform.release()
+                    m = re.match(r"2.6.(\d{1,2})", kernel_version)
+                    can = m is None or int(m.group(1)) >= 39
+                except OSError:
+                    can = False
+        finally:
+            unlink(TESTFN)
+            unlink(tmp_name)
+            rmdir(tmp_dir)
+    _can_xattr = can
+    return can
+
+
+def skip_unless_xattr(test):
+    """Skip decorator for tests that require functional extended attributes"""
+    ok = can_xattr()
+    msg = "no non-broken extended attribute support"
+    return test if ok else unittest.skip(msg)(test)
+
+
+def unlink(filename):
+    try:
+        _unlink(filename)
+    except (FileNotFoundError, NotADirectoryError):
+        pass
+
+
+if sys.platform.startswith("win"):
+    def _waitfor(func, pathname, waitall=False):
+        # Perform the operation
+        func(pathname)
+        # Now setup the wait loop
+        if waitall:
+            dirname = pathname
+        else:
+            dirname, name = os.path.split(pathname)
+            dirname = dirname or '.'
+        # Check for `pathname` to be removed from the filesystem.
+        # The exponential backoff of the timeout amounts to a total
+        # of ~1 second after which the deletion is probably an error
+        # anyway.
+        # Testing on an i7@4.3GHz shows that usually only 1 iteration is
+        # required when contention occurs.
+        timeout = 0.001
+        while timeout < 1.0:
+            # Note we are only testing for the existence of the file(s) in
+            # the contents of the directory regardless of any security or
+            # access rights.  If we have made it this far, we have sufficient
+            # permissions to do that much using Python's equivalent of the
+            # Windows API FindFirstFile.
+            # Other Windows APIs can fail or give incorrect results when
+            # dealing with files that are pending deletion.
+            L = os.listdir(dirname)
+            if not (L if waitall else name in L):
+                return
+            # Increase the timeout and try again
+            time.sleep(timeout)
+            timeout *= 2
+        warnings.warn('tests may fail, delete still pending for ' + pathname,
+                      RuntimeWarning, stacklevel=4)
+
+    def _unlink(filename):
+        _waitfor(os.unlink, filename)
+
+    def _rmdir(dirname):
+        _waitfor(os.rmdir, dirname)
+
+    def _rmtree(path):
+        from test.support import _force_run
+
+        def _rmtree_inner(path):
+            for name in _force_run(path, os.listdir, path):
+                fullname = os.path.join(path, name)
+                try:
+                    mode = os.lstat(fullname).st_mode
+                except OSError as exc:
+                    print("support.rmtree(): os.lstat(%r) failed with %s"
+                          % (fullname, exc),
+                          file=sys.__stderr__)
+                    mode = 0
+                if stat.S_ISDIR(mode):
+                    _waitfor(_rmtree_inner, fullname, waitall=True)
+                    _force_run(fullname, os.rmdir, fullname)
+                else:
+                    _force_run(fullname, os.unlink, fullname)
+        _waitfor(_rmtree_inner, path, waitall=True)
+        _waitfor(lambda p: _force_run(p, os.rmdir, p), path)
+
+    def _longpath(path):
+        try:
+            import ctypes
+        except ImportError:
+            # No ctypes means we can't expands paths.
+            pass
+        else:
+            buffer = ctypes.create_unicode_buffer(len(path) * 2)
+            length = ctypes.windll.kernel32.GetLongPathNameW(path, buffer,
+                                                             len(buffer))
+            if length:
+                return buffer[:length]
+        return path
+else:
+    _unlink = os.unlink
+    _rmdir = os.rmdir
+
+    def _rmtree(path):
+        import shutil
+        try:
+            shutil.rmtree(path)
+            return
+        except OSError:
+            pass
+
+        def _rmtree_inner(path):
+            from test.support import _force_run
+            for name in _force_run(path, os.listdir, path):
+                fullname = os.path.join(path, name)
+                try:
+                    mode = os.lstat(fullname).st_mode
+                except OSError:
+                    mode = 0
+                if stat.S_ISDIR(mode):
+                    _rmtree_inner(fullname)
+                    _force_run(path, os.rmdir, fullname)
+                else:
+                    _force_run(path, os.unlink, fullname)
+        _rmtree_inner(path)
+        os.rmdir(path)
+
+    def _longpath(path):
+        return path
+
+
+def rmdir(dirname):
+    try:
+        _rmdir(dirname)
+    except FileNotFoundError:
+        pass
+
+
+def rmtree(path):
+    try:
+        _rmtree(path)
+    except FileNotFoundError:
+        pass
+
+
+@contextlib.contextmanager
+def temp_dir(path=None, quiet=False):
+    """Return a context manager that creates a temporary directory.
+
+    Arguments:
+
+      path: the directory to create temporarily.  If omitted or None,
+        defaults to creating a temporary directory using tempfile.mkdtemp.
+
+      quiet: if False (the default), the context manager raises an exception
+        on error.  Otherwise, if the path is specified and cannot be
+        created, only a warning is issued.
+
+    """
+    import tempfile
+    dir_created = False
+    if path is None:
+        path = tempfile.mkdtemp()
+        dir_created = True
+        path = os.path.realpath(path)
+    else:
+        try:
+            os.mkdir(path)
+            dir_created = True
+        except OSError as exc:
+            if not quiet:
+                raise
+            warnings.warn(f'tests may fail, unable to create '
+                          f'temporary directory {path!r}: {exc}',
+                          RuntimeWarning, stacklevel=3)
+    if dir_created:
+        pid = os.getpid()
+    try:
+        yield path
+    finally:
+        # In case the process forks, let only the parent remove the
+        # directory. The child has a different process id. (bpo-30028)
+        if dir_created and pid == os.getpid():
+            rmtree(path)
+
+
+@contextlib.contextmanager
+def change_cwd(path, quiet=False):
+    """Return a context manager that changes the current working directory.
+
+    Arguments:
+
+      path: the directory to use as the temporary current working directory.
+
+      quiet: if False (the default), the context manager raises an exception
+        on error.  Otherwise, it issues only a warning and keeps the current
+        working directory the same.
+
+    """
+    saved_dir = os.getcwd()
+    try:
+        os.chdir(os.path.realpath(path))
+    except OSError as exc:
+        if not quiet:
+            raise
+        warnings.warn(f'tests may fail, unable to change the current working '
+                      f'directory to {path!r}: {exc}',
+                      RuntimeWarning, stacklevel=3)
+    try:
+        yield os.getcwd()
+    finally:
+        os.chdir(saved_dir)
+
+
+@contextlib.contextmanager
+def temp_cwd(name='tempcwd', quiet=False):
+    """
+    Context manager that temporarily creates and changes the CWD.
+
+    The function temporarily changes the current working directory
+    after creating a temporary directory in the current directory with
+    name *name*.  If *name* is None, the temporary directory is
+    created using tempfile.mkdtemp.
+
+    If *quiet* is False (default) and it is not possible to
+    create or change the CWD, an error is raised.  If *quiet* is True,
+    only a warning is raised and the original CWD is used.
+
+    """
+    with temp_dir(path=name, quiet=quiet) as temp_path:
+        with change_cwd(temp_path, quiet=quiet) as cwd_dir:
+            yield cwd_dir
+
+
+def create_empty_file(filename):
+    """Create an empty file. If the file already exists, truncate it."""
+    fd = os.open(filename, os.O_WRONLY | os.O_CREAT | os.O_TRUNC)
+    os.close(fd)
+
+
+@contextlib.contextmanager
+def open_dir_fd(path):
+    """Open a file descriptor to a directory."""
+    assert os.path.isdir(path)
+    dir_fd = os.open(path, os.O_RDONLY)
+    try:
+        yield dir_fd
+    finally:
+        os.close(dir_fd)
+
+
+def fs_is_case_insensitive(directory):
+    """Detects if the file system for the specified directory
+    is case-insensitive."""
+    import tempfile
+    with tempfile.NamedTemporaryFile(dir=directory) as base:
+        base_path = base.name
+        case_path = base_path.upper()
+        if case_path == base_path:
+            case_path = base_path.lower()
+        try:
+            return os.path.samefile(base_path, case_path)
+        except FileNotFoundError:
+            return False
+
+
+class FakePath:
+    """Simple implementing of the path protocol.
+    """
+    def __init__(self, path):
+        self.path = path
+
+    def __repr__(self):
+        return f'<FakePath {self.path!r}>'
+
+    def __fspath__(self):
+        if (isinstance(self.path, BaseException) or
+            isinstance(self.path, type) and
+                issubclass(self.path, BaseException)):
+            raise self.path
+        else:
+            return self.path
+
+
+def fd_count():
+    """Count the number of open file descriptors.
+    """
+    if sys.platform.startswith(('linux', 'freebsd')):
+        try:
+            names = os.listdir("/proc/self/fd")
+            # Subtract one because listdir() internally opens a file
+            # descriptor to list the content of the /proc/self/fd/ directory.
+            return len(names) - 1
+        except FileNotFoundError:
+            pass
+
+    MAXFD = 256
+    if hasattr(os, 'sysconf'):
+        try:
+            MAXFD = os.sysconf("SC_OPEN_MAX")
+        except OSError:
+            pass
+
+    old_modes = None
+    if sys.platform == 'win32':
+        # bpo-25306, bpo-31009: Call CrtSetReportMode() to not kill the process
+        # on invalid file descriptor if Python is compiled in debug mode
+        try:
+            import msvcrt
+            msvcrt.CrtSetReportMode
+        except (AttributeError, ImportError):
+            # no msvcrt or a release build
+            pass
+        else:
+            old_modes = {}
+            for report_type in (msvcrt.CRT_WARN,
+                                msvcrt.CRT_ERROR,
+                                msvcrt.CRT_ASSERT):
+                old_modes[report_type] = msvcrt.CrtSetReportMode(report_type,
+                                                                 0)
+
+    try:
+        count = 0
+        for fd in range(MAXFD):
+            try:
+                # Prefer dup() over fstat(). fstat() can require input/output
+                # whereas dup() doesn't.
+                fd2 = os.dup(fd)
+            except OSError as e:
+                if e.errno != errno.EBADF:
+                    raise
+            else:
+                os.close(fd2)
+                count += 1
+    finally:
+        if old_modes is not None:
+            for report_type in (msvcrt.CRT_WARN,
+                                msvcrt.CRT_ERROR,
+                                msvcrt.CRT_ASSERT):
+                msvcrt.CrtSetReportMode(report_type, old_modes[report_type])
+
+    return count
+
+
+if hasattr(os, "umask"):
+    @contextlib.contextmanager
+    def temp_umask(umask):
+        """Context manager that temporarily sets the process umask."""
+        oldmask = os.umask(umask)
+        try:
+            yield
+        finally:
+            os.umask(oldmask)
+
+
+class EnvironmentVarGuard(collections.abc.MutableMapping):
+
+    """Class to help protect the environment variable properly.  Can be used as
+    a context manager."""
+
+    def __init__(self):
+        self._environ = os.environ
+        self._changed = {}
+
+    def __getitem__(self, envvar):
+        return self._environ[envvar]
+
+    def __setitem__(self, envvar, value):
+        # Remember the initial value on the first access
+        if envvar not in self._changed:
+            self._changed[envvar] = self._environ.get(envvar)
+        self._environ[envvar] = value
+
+    def __delitem__(self, envvar):
+        # Remember the initial value on the first access
+        if envvar not in self._changed:
+            self._changed[envvar] = self._environ.get(envvar)
+        if envvar in self._environ:
+            del self._environ[envvar]
+
+    def keys(self):
+        return self._environ.keys()
+
+    def __iter__(self):
+        return iter(self._environ)
+
+    def __len__(self):
+        return len(self._environ)
+
+    def set(self, envvar, value):
+        self[envvar] = value
+
+    def unset(self, envvar):
+        del self[envvar]
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *ignore_exc):
+        for (k, v) in self._changed.items():
+            if v is None:
+                if k in self._environ:
+                    del self._environ[k]
+            else:
+                self._environ[k] = v
+        os.environ = self._environ