././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5595517 setuptools-68.1.2/0000755000175100001730000000000014467657444013457 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/LICENSE0000644000175100001730000000177714467657412014473 0ustar00runnerdockerPermission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/MANIFEST.in0000644000175100001730000000121014467657412015202 0ustar00runnerdockerrecursive-include setuptools *.py *.exe *.xml *.tmpl recursive-include tests *.py recursive-include setuptools/tests *.html recursive-include docs *.py *.txt *.rst *.conf *.css *.css_t Makefile indexsidebar.html recursive-include setuptools/_vendor *.py *.txt recursive-include pkg_resources *.py *.txt recursive-include pkg_resources/tests/data * recursive-include tools * recursive-include newsfragments * include *.py include *.rst include MANIFEST.in include LICENSE include launcher.c include msvc-build-launcher.cmd include pytest.ini include tox.ini include setuptools/tests/config/setupcfg_examples.txt global-exclude *.py[cod] __pycache__ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/NEWS.rst0000644000175100001730000067765214467657412015007 0ustar00runnerdockerv68.1.2 ======= Misc ---- - #4022, #4022 v68.1.1 ======= Bugfixes -------- - Fix editable install finder handling of nested packages, by only handling 1 level of nesting and relying on ``importlib.machinery`` to find the remaining modules based on the parent package path. (#4020) v68.1.0 ======= Features -------- - Removed code referencing bdist_wininst in install_scripts. (#3525) - Promote ``pyproject.toml``'s ``[tool.setuptools]`` out of beta. Note that some fields are still considered deprecated and/or obsolete, and these might be removed in future versions (i.e., there is no guarantee for long term support and backward compatibility on those fields). (#3962) - Automatically add files listed in ``Extension.depends`` to sdists, as long as they are contained in the project directory -- by :user:`RuRo` (#4000) - Require Python 3.8 or later. Bugfixes -------- - Made imports in editable installs case-sensitive on case-insensitive filesystems -- by :user:`aganders3` (#3995) - Use default encoding to create ``.pth`` files with ``editable_wheel``. (#4009) - Detects (and complain about) ``scripts`` and ``gui-scripts`` set via ``setup.py`` when ``pyproject.toml`` does not include them in ``dynamic``. (#4012) Misc ---- - #3833, #3960, #4001, #4007 v68.0.0 ======= Breaking Changes ---------------- * #3948: Removed verification for existing ``depends.txt`` file (deprecated since v0.5a4). * #3948: Remove autofixing of broken ``.egg-info`` directories containing the ``-`` character in their base name (without suffix). They should no longer be produced by sufficiently new versions of ``setuptools`` (warning introduced in 2005). * #3948: Remove deprecated APIs in ``easy_install``: ``get_script_args``, ``get_script_header`` and ``get_writer``. The direct usage of ``easy_install`` has been deprecated since v58.3.0, and the warnings regarding these APIs predate that version. * #3948: Removed ``egg_info.get_pkg_info_revision`` (deprecated since 2015). * #3948: Removed ``setuptools.dist._get_unpatched`` (deprecated since 2016) * #3948: Removed support for SVN in ``setuptools.package_index`` (deprecated since 2018). * #3948: Removed support for invalid ``pyproject.toml`` files. During the implementation of PEP 621, it was identified that some users were producing invalid files. As a transitional measure, the validation was relaxed for a few use cases. The grace period, however, came to an end. Changes ------- * #3760: Added symlink support to launcher for installed executables -- by :user:`eugene-sevostianov-sc` * #3926: Updated vendored ``packaging`` version from 23.0 to 23.1 -- by :user:`MetRonnie` * #3950: Implemented workaround for old versions of ``vswhere``, which miss the ``-requiresAny`` parameter, such as the ones distributed together with Visual Studio 2017 < 15.6. * #3952: Changed ``DistutilsMetaFinder`` to skip ``spec_for_pip`` on Python >= 3.12. * #3952: Removed ``_distutils_hack.remove_shim`` on Python >= 3.12 (since ``distutils`` was removed from the standard library, ``DistutilsMetaFinder`` cannot be disabled on Python >= 3.12). Misc ---- * #3920: Add a link to deprecation warning in ``pkg_resources`` and improve ``stacklevel`` for better visibility. v67.8.0 ======= Changes ------- * #3128: In deprecated easy_install, reload and merge the pth file before saving. Misc ---- * #3915: Adequate tests to the latest changes in ``virtualenv`` for Python 3.12. v67.7.2 ======= Misc ---- * #3902: Fixed wrong URLs used in warnings and logs. v67.7.1 ======= Misc ---- * #3898: Fixes setuptools.dist:invalid_unless_false when value is false don't raise error -- by :user:`jammarher` v67.7.0 ======= Changes ------- * #3849: Overhaul warning system for better visibility. Documentation changes --------------------- * #3859: Added a note about historical presence of ``wheel`` in ``build-system.requires``, in ``pyproject.toml``. * #3893: Improved the documentation example regarding making a thin :pep:`517` in-tree backend wrapper of ``setuptools.build_meta`` that is future-proof and supports :pep:`660` hook too -- by :user:`webknjaz`. Misc ---- * #3884: Add a ``stacklevel`` parameter to ``warnings.warn()`` to provide more information to the user. -- by :user:`cclauss` v67.6.1 ======= Misc ---- * #3865: Fixed ``_WouldIgnoreField`` warnings for ``scripts`` and ``gui_scripts``, when ``entry-points`` is not listed in dynamic. * #3875: Update code generated by ``validate-pyproject`` to use v0.12.2. This should fix default license patterns when ``pyproject.toml`` is used. v67.6.0 ======= Changes ------- * #3804: Added caching for supported wheel tags. * #3846: Added pruning heuristics to ``PackageFinder`` based on ``exclude``. v67.5.1 ======= Misc ---- * #3836: Fixed interaction between ``setuptools``' package auto-discovery and auto-generated ``htmlcov`` files. Previously, the ``htmlcov`` name was ignored when searching for single-file modules, however the correct behaviour is to ignore it when searching for packages (since it is supposed to be a directory, see `coverage config`_) -- by :user:`yukihiko-shinoda`. .. _coverage config: https://coverage.readthedocs.io/en/stable/config.html#html-directory * #3838: Improved error messages for ``pyproject.toml`` validations. * #3839: Fixed ``pkg_resources`` errors caused when parsing metadata of packages that are already installed but do not conform with PEP 440. v67.5.0 ======= Changes ------- * #3843: Although pkg_resources has been discouraged for use, some projects still consider pkg_resources viable for usage. This change makes it clear that pkg_resources should not be used, emitting a DeprecationWarning when imported. v67.4.0 ======= Changes ------- * #3832: Update vendored ``importlib-metadata`` (to 6.0.0) and ``importlib-resources`` (to 5.10.2) v67.3.3 ======= Misc ---- * #3820: Restore quoted ``#include`` argument to ``has_function``. v67.3.2 ======= Misc ---- * #3827: Improve deprecation warning message on ``pkg_resources.declare_namespace`` to display package name. v67.3.1 ======= Misc ---- * #3823: Fixes ``egg_info`` code path triggered during integration with ``pip``. v67.3.0 ======= Deprecations ------------ * #3434: Added deprecation warning for ``pkg_resources.declare_namespace``. Users that wish to implement namespace packages, are recommended to follow the practice described in PEP 420 and omit the ``__init__.py`` file entirely. Changes ------- * #3792: Reduced usage of ``pkg_resources`` in ``setuptools`` via internal restructuring and refactoring. Misc ---- * #3822: Added debugging tips for "editable mode" and update related docs. Instead of using a custom exception to display the help message to the user, ``setuptools`` will now use a warning and re-raise the original exception. * #3822: Added clarification about ``editable_wheel`` and ``dist_info`` CLI commands: they should not be called directly with ``python setup.py ...``. Instead they are reserved for internal use of ``setuptools`` (effectively as "private" commands). Users are recommended to rely on build backend APIs (:pep:`517` and :pep:`660`) exposed by ``setuptools.build_meta``. v67.2.0 ======= Changes ------- * #3809: Merge with distutils@8c3c3d29, including fix for ``sysconfig.get_python_inc()`` (pypa/distutils#178), fix for segfault on MinGW (pypa/distutils#196), and better ``has_function`` support (pypa/distutils#195, #3648). v67.1.0 ======= Changes ------- * #3795: Ensured that ``__file__`` is an absolute path when executing ``setup.py`` as part of ``setuptools.build_meta``. Misc ---- * #3798: Updated validations for ``pyproject.toml`` using ``validate-pyproject==0.12.1`` to allow stub packages (:pep:`561`) to be listed in ``tool.setuptools.packages`` and ``tool.setuptools.package-dir``. v67.0.0 ======= Breaking Changes ---------------- * #3741: Removed patching of ``distutils._msvccompiler.gen_lib_options`` for compatibility with Numpy < 1.11.2 -- by :user:`mgorny` * #3790: Bump vendored version of :pypi:`packaging` to 23.0 (:pypi:`pyparsing` is no longer required and was removed). As a consequence, users will experience a more strict parsing of requirements. Specifications that don't comply with :pep:`440` and :pep:`508` will result in build errors. v66.1.1 ======= Misc ---- * #3782: Fixed problem with ``file`` directive in ``tool.setuptools.dynamic`` (``pyproject.toml``) when value is a simple string instead of list. v66.1.0 ======= Changes ------- * #3685: Fix improper usage of deprecated/removed ``pkgutil`` APIs in Python 3.12+. * #3779: Files referenced by ``file:`` in ``setup.cfg`` and by ``project.readme.file``, ``project.license.file`` or ``tool.setuptools.dynamic.*.file`` in ``pyproject.toml`` are now automatically included in the generated sdists. Misc ---- * #3776: Added note about using the ``--pep-517`` flag with ``pip`` to workaround ``InvalidVersion`` errors for packages that are already installed in the system. v66.0.0 ======= Breaking Changes ---------------- * #2497: Support for PEP 440 non-conforming versions has been removed. Environments containing packages with non-conforming versions may fail or the packages may not be recognized. Changes ------- * #3769: Replace 'appdirs' with 'platformdirs'. v65.7.0 ======= Changes ------- * #3594: Added ``htmlcov`` to FlatLayoutModuleFinder.DEFAULT_EXCLUDE -- by :user:`demianbrecht` * #3667: Added a human-readable error description when ``.egg-info`` directory is not writeable -- by :user:`droodev` Misc ---- * #3713: Fixed incomplete ``getattr`` statement that caused problems when accessing undefined attribute. v65.6.3 ======= Misc ---- * #3709: Fix condition to patch ``distutils.dist.log`` to only apply when using ``distutils`` from the stdlib. v65.6.2 ======= No significant changes. v65.6.1 ======= Documentation changes --------------------- * #3689: Documented that ``distutils.cfg`` might be ignored unless ``SETUPTOOLS_USE_DISTUTILS=stdlib``. Misc ---- * #3678: Improve clib builds reproducibility by sorting sources -- by :user:`danigm` * #3684: Improved exception/traceback when invalid entry-points are specified. * #3690: Fixed logging errors: 'underlying buffer has been detached' (issue #1631). * #3693: Merge pypa/distutils@3e9d47e with compatibility fix for distutils.log.Log. * #3695, #3697, #3698, #3699: Changed minor text details (spelling, spaces ...) * #3696: Removed unnecessary ``coding: utf-8`` annotations * #3704: Fixed temporary build directories interference with auto-discovery. v65.6.0 ======= Changes ------- * #3674: Sync with pypa/distutils@e0787fa, including pypa/distutils#183 updating distutils to use the Python logging framework. v65.5.1 ======= Misc ---- * #3638: Drop a test dependency on the ``mock`` package, always use :external+python:py:mod:`unittest.mock` -- by :user:`hroncok` * #3659: Fixed REDoS vector in package_index. v65.5.0 ======= Changes ------- * #3624: Fixed editable install for multi-module/no-package ``src``-layout projects. * #3626: Minor refactorings to support distutils using stdlib logging module. Documentation changes --------------------- * #3419: Updated the example version numbers to be compliant with PEP-440 on the "Specifying Your Project’s Version" page of the user guide. Misc ---- * #3569: Improved information about conflicting entries in the current working directory and editable install (in documentation and as an informational warning). * #3576: Updated version of ``validate_pyproject``. v65.4.1 ======= Misc ---- * #3613: Fixed encoding errors in ``expand.StaticModule`` when system default encoding doesn't match expectations for source files. * #3617: Merge with pypa/distutils@6852b20 including fix for pypa/distutils#181. v65.4.0 ======= Changes ------- * #3609: Merge with pypa/distutils@d82d926 including support for DIST_EXTRA_CONFIG in pypa/distutils#177. v65.3.0 ======= Changes ------- * #3547: Stop ``ConfigDiscovery.analyse_name`` from splatting the ``Distribution.name`` attribute -- by :user:`jeamland` Documentation changes --------------------- * #3554: Changed requires to requests in the pyproject.toml example in the :doc:`Dependency management section of the Quickstart guide ` -- by :user:`mfbutner` Misc ---- * #3561: Fixed accidental name matching in editable hooks. v65.2.0 ======= Changes ------- * #3553: Sync with pypa/distutils@22b9bcf, including fixed cross-compiling support and removing deprecation warning per pypa/distutils#169. v65.1.1 ======= Misc ---- * #3551: Avoided circular imports in meta path finder for editable installs when a missing module has the same name as its parent. v65.1.0 ======= Changes ------- * #3536: Remove monkeypatching of msvc9compiler. Documentation changes --------------------- * #3538: Corrected documentation on how to use the ``legacy-editable`` mode. v65.0.2 ======= Misc ---- * #3505: Restored distutils msvccompiler and msvc9compiler modules and marked as deprecated (pypa/distutils@c802880). v65.0.1 ======= Documentation changes --------------------- * #3529: Added clarification to :doc:`/userguide/quickstart` about support to ``setup.py``. Misc ---- * #3526: Fixed backward compatibility of editable installs and custom ``build_ext`` commands inheriting directly from ``distutils``. * #3528: Fixed ``buid_meta.prepare_metadata_for_build_wheel`` when given ``metadata_directory`` is ``"."``. v65.0.0 ======= Breaking Changes ---------------- * #3505: Removed 'msvccompiler' and 'msvc9compiler' modules from distutils. * #3521: Remove bdist_msi and bdist_wininst commands, which have been deprecated since Python 3.9. Use older Setuptools for these behaviors if needed. Documentation changes --------------------- * #3519: Changed the note in ``keywords`` documentation regarding editable installations to specify which ``setuptools`` version require a minimal ``setup.py`` file or not. v64.0.3 ======= Misc ---- * #3515: Fixed "inline" file copying for editable installations and optional extensions. * #3517: Fixed ``editable_wheel`` to ensure other commands are finalized before using them. This should prevent errors with plugins trying to use different commands or reinitializing them. * #3517: Augmented filter to prevent transient/temporary source files from being considered ``package_data`` or ``data_files``. v64.0.2 ======= Misc ---- * #3506: Suppress errors in custom ``build_py`` implementations when running editable installs in favor of a warning indicating what is the most appropriate migration path. This is a *transitional* measure. Errors might be raised in future versions of ``setuptools``. * #3512: Added capability of handling namespace packages created accidentally/purposefully via discovery configuration during editable installs. This should emulate the behaviour of a non-editable installation. v64.0.1 ======= Misc ---- * #3497: Fixed ``editable_wheel`` for legacy namespaces. * #3502: Fixed issue with editable install and single module distributions. * #3503: Added filter to ignore external ``.egg-info`` files in manifest. Some plugins might rely on the fact that the ``.egg-info`` directory is produced inside the project dir, which may not be the case in editable installs (the ``.egg-info`` directory is produced inside the metadata directory given by the build frontend via PEP 660 hooks). v64.0.0 ======= Deprecations ------------ * #3380: Passing some types of parameters via ``--global-option`` to setuptools PEP 517/PEP 660 backend is now considered deprecated. The user can pass the same arbitrary parameter via ``--build-option`` (``--global-option`` is now reserved for flags like ``--verbose`` or ``--quiet``). Both ``--build-option`` and ``--global-option`` are supported as a **transitional** effort (a.k.a. "escape hatch"). In the future a proper list of allowed ``config_settings`` may be created. Breaking Changes ---------------- * #3265: Added implementation for *editable install* hooks (PEP 660). By default the users will experience a *lenient* behavior which prioritises the ability of the users of changing the distributed packages (e.g. adding new files or removing old ones). But they can also opt into a *strict* mode, which will try to replicate as much as possible the behavior of the package as if it would be normally installed by end users. The *strict* editable installation is not able to detect if files are added or removed from the project (a new installation is required). This implementation might also affect plugins and customizations that assume certain ``build`` subcommands don't run during editable installs or that they always copy files to the temporary build directory. .. important:: The *editable* aspect of the *editable install* supported this implementation is restricted to the Python modules contained in the distributed package. Changes in binary extensions (e.g. C/C++), entry-point definitions, dependencies, metadata, datafiles, etc may require a new installation. Changes ------- * #3380: Improved the handling of the ``config_settings`` parameter in both PEP 517 and PEP 660 interfaces: - It is possible now to pass both ``--global-option`` and ``--build-option``. As discussed in #1928, arbitrary arguments passed via ``--global-option`` should be placed before the name of the setuptools' internal command, while ``--build-option`` should come after. - Users can pass ``editable-mode=strict`` to select a strict behaviour for the editable installation. * #3392: Exposed ``get_output_mapping()`` from ``build_py`` and ``build_ext`` subcommands. This interface is reserved for the use of ``setuptools`` Extensions and third part packages are explicitly disallowed to calling it. However, any implementation overwriting ``build_py`` or ``build_ext`` are required to honour this interface. * #3412: Added ability of collecting source files from custom build sub-commands to ``sdist``. This allows plugins and customization scripts to automatically add required source files in the source distribution. * #3414: Users can *temporarily* specify an environment variable ``SETUPTOOLS_ENABLE_FEATURES=legacy-editable`` as a escape hatch for the :pep:`660` behavior. This setting is **transitional** and may be removed in the future. * #3484: Added *transient* ``compat`` mode to editable installs. This more will be temporarily available (to facilitate the transition period) for those that want to emulate the behavior of the ``develop`` command (in terms of what is added to ``sys.path``). This mode is provided "as is", with limited support, and will be removed in future versions of ``setuptools``. Documentation changes --------------------- * #3414: Updated :doc:`Development Mode ` to reflect on the implementation of :pep:`660`. v63.4.3 ======= Misc ---- * #3496: Update to pypa/distutils@b65aa40 including more robust support for library/include dir handling in msvccompiler (pypa/distutils#153) and test suite improvements. v63.4.2 ======= Misc ---- * #3453: Bump vendored version of :pypi:`pyparsing` to 3.0.9. * #3481: Add warning for potential ``install_requires`` and ``extras_require`` misconfiguration in ``setup.cfg`` * #3487: Modified ``pyproject.toml`` validation exception handling to make relevant debugging information easier to spot. v63.4.1 ======= Misc ---- * #3482: Sync with pypa/distutils@274758f1c02048d295efdbc13d2f88d9923547f8, restoring compatibility shim in bdist.format_commands. v63.4.0 ======= Changes ------- * #2971: ``upload_docs`` command is deprecated once again. Documentation changes --------------------- * #3443: Installed ``sphinx-hoverxref`` extension to show tooltips on internal an external references. -- by :user:`humitos` * #3444: Installed ``sphinx-notfound-page`` extension to generate nice 404 pages. -- by :user:`humitos` Misc ---- * #3480: Merge with pypa/distutils@c397f4c v63.3.0 ======= Changes ------- * #3475: Merge with pypa/distutils@129480b, including substantial delinting and cleanup, some refactoring around compiler logic, better messaging in cygwincompiler (pypa/distutils#161). v63.2.0 ======= Changes ------- * #3395: Included a performance optimization: ``setuptools.build_meta`` no longer tries to :func:`compile` the setup script code before :func:`exec`-ing it. Misc ---- * #3435: Corrected issue in macOS framework builds on Python 3.9 not installed by homebrew (pypa/distutils#158). v63.1.0 ======= Changes ------- * #3430: Merge with pypa/distutils@152c13d including pypa/distutils#155 (improved compatibility for editable installs on homebrew Python 3.9), pypa/distutils#150 (better handling of runtime_library_dirs on cygwin), and pypa/distutils#151 (remove warnings for namespace packages). v63.0.0 ======= Breaking Changes ---------------- * #3421: Drop setuptools' support for installing an entrypoint extra requirements at load time: - the functionality has been broken since v60.8.0. - the mechanism to do so is deprecated (``fetch_build_eggs``). - that use case (e.g. a custom command class entrypoint) is covered by making sure the necessary build requirements are declared. Documentation changes --------------------- * #3305: Updated the example pyproject.toml -- by :user:`jacalata` * #3394: This updates the documentation for the ``file_finders`` hook so that the logging recommendation aligns with the suggestion to not use ``distutils`` directly. * #3397: Fix reference for ``keywords`` to point to the Core Metadata Specification instead of PEP 314 (the live standard is kept always up-to-date and consolidates several PEPs together in a single document). * #3402: Reordered the User Guide's Table of Contents -- by :user:`codeandfire` v62.6.0 ======= Changes ------- * #3253: Enabled using ``file:`` for requirements in setup.cfg -- by :user:`akx` (this feature is currently considered to be in **beta** stage). * #3255: Enabled using ``file:`` for dependencies and optional-dependencies in pyproject.toml -- by :user:`akx` (this feature is currently considered to be in **beta** stage). * #3391: Updated ``attr:`` to also extract simple constants with type annotations -- by :user:`karlotness` v62.5.0 ======= Changes ------- * #3347: Changed warnings and documentation notes about *experimental* aspect of ``pyproject.toml`` configuration: now ``[project]`` is a fully supported configuration interface, but the ``[tool.setuptools]`` table and sub-tables are still considered to be in **beta** stage. * #3383: In _distutils_hack, suppress/undo the use of local distutils when select tests are imported in CPython. Documentation changes --------------------- * #3368: Added documentation page about extension modules -- by :user:`mkoeppe` * #3371: Moved documentation from ``/userguide/commands`` to ``/depracted/commands``. This change was motived by the fact that running ``python setup.py`` directly is considered a deprecated practice. * #3372: Consolidated sections about ``sdist`` contents and ``MANIFEST.in`` into a single page. Added a simple ``MANIFEST.in`` example. * #3373: Moved remarks about using :pypi:`Cython` to the newly created page for extension modules. * #3374: Added clarification that using ``python setup.py egg_info`` commands to manage project versions is only supported in a *transitional* basis, and that eventually ``egg_info`` will be deprecated. Reorganized sections with tips for managing versions. * #3378: Updated ``Quickstart`` docs to make it easier to follow for beginners. Misc ---- * #3385: Modules used to parse and evaluate configuration from ``pyproject.toml`` files are intended for internal use only and that not part of the public API. v62.4.0 ======= Changes ------- * #3256: Added setuptools.command.build command to match distutils.command.build -- by :user:`isuruf` * #3366: Merge with pypa/distutils@75ed79d including reformat using black, fix for Cygwin support (pypa/distutils#139), and improved support for cross compiling (pypa/distutils#144 and pypa/distutils#145). Documentation changes --------------------- * #3355: Changes to the User Guide's Entry Points page -- by :user:`codeandfire` * #3361: Further minor corrections to the Entry Points page -- by :user:`codeandfire` * #3363: Rework some documentation pages to de-emphasize ``distutils`` and the history of packaging in the Python ecosystem. The focus of these changes is to make the documentation easier to read for new users. * #3364: Update documentation about dependency management, removing mention to the deprecated ``dependency_links`` and adding some small improvements. * #3367: Extracted text about automatic resource extraction and the zip-safe flag from ``userguide/miscellaneous`` to ``deprecated/resource_extraction`` and ``deprecated/zip_safe``. Extracted text about additional metadata files from ``userguide/miscellaneous`` into the existing ``userguide/extension`` document. Updated ``userguide/extension`` to better reflect the status of the setuptools project. Removed ``userguide/functionalities_rewrite`` (a virtually empty part of the docs). v62.3.4 ======= Documentation changes --------------------- * #3349: Fixed two small issues preventing docs from building locally -- by :user:`codeandfire` * #3350: Added note explaining ``package_data`` glob pattern matching for dotfiles -- by :user:`comabrewer` * #3358: Clarify the role of the ``package_dir`` configuration. Misc ---- * #3354: Improve clarity in warning about unlisted namespace packages. v62.3.3 ======= Documentation changes --------------------- * #3331: Replaced single backticks with double ones in ``CHANGES.rst`` -- by :user:`codeandfire` * #3332: Fixed grammar/typos, modified example directory trees for src-layout and flat-layout -- by :user:`codeandfire` * #3335: Changes to code snippets and other examples in the Data Files page of the User Guide -- by :user:`codeandfire` Misc ---- * #3336: Modified ``test_setup_install_includes_dependencies`` to work with custom ``PYTHONPATH`` –- by :user:`hroncok` v62.3.2 ======= Misc ---- * #3328: Include a first line summary to some of the existing multi-line warnings. v62.3.1 ======= Misc ---- * #3320: Fixed typo which causes ``namespace_packages`` to raise an error instead of warning. v62.3.0 ======= Deprecations ------------ * #3262: Formally added deprecation messages for ``namespace_packages``. The methodology that uses ``pkg_resources`` and ``namespace_packages`` for creating namespaces was already discouraged by the :doc:`setuptools docs ` and the :doc:`Python Packaging User Guide `, therefore this change just make the deprecation more official. Users can consider migrating to native/implicit namespaces (as introduced in :pep:`420`). * #3308: Relying on ``include_package_data`` to ensure sub-packages are automatically added to the build wheel distribution (as "data") is now considered a deprecated practice. This behaviour was controversial and caused inconsistencies (#3260). Instead, projects are encouraged to properly configure ``packages`` or use discovery tools. General information can be found in :doc:`userguide/package_discovery`. Changes ------- * #1806: Allowed recursive globs (``**``) in ``package_data``. -- by :user:`nullableVoidPtr` * #3206: Fixed behaviour when both ``install_requires`` (in ``setup.py``) and ``dependencies`` (in ``pyproject.toml``) are specified. The configuration in ``pyproject.toml`` will take precedence over ``setup.py`` (in accordance with PEP 621). A warning was added to inform users. Documentation changes --------------------- * #3307: Added introduction to references/keywords. Added deprecation tags to test kwargs. Moved userguide/keywords to deprecated section. Clarified in deprecated doc what keywords came from distutils and which were added or changed by setuptools. Misc ---- * #3274: Updated version of vendored ``pyparsing`` to 3.0.8 to avoid problems with upcoming deprecation in Python 3.11. * #3292: Added warning about incompatibility with old versions of ``importlib-metadata``. v62.2.0 ======= Changes ------- * #3299: Optional metadata fields are now truly optional. Includes merge with pypa/distutils@a7cfb56 per pypa/distutils#138. Misc ---- * #3282: Added CI cache for ``setup.cfg`` examples used when testing ``setuptools.config``. v62.1.0 ======= Changes ------- * #3258: Merge pypa/distutils@5229dad46b. Misc ---- * #3249: Simplified ``package_dir`` obtained via auto-discovery. v62.0.0 ======= Breaking Changes ---------------- * #3151: Made ``setup.py develop --user`` install to the user site packages directory even if it is disabled in the current interpreter. Changes ------- * #3153: When resolving requirements use both canonical and normalized names -- by :user:`ldaniluk` * #3167: Honor unix file mode in ZipFile when installing wheel via ``install_as_egg`` -- by :user:`delijati` Misc ---- * #3088: Fixed duplicated tag with the ``dist-info`` command. * #3247: Fixed problem preventing ``readme`` specified as dynamic in ``pyproject.toml`` from being dynamically specified in ``setup.py``. v61.3.1 ======= Misc ---- * #3233: Included missing test file ``setupcfg_examples.txt`` in ``sdist``. * #3233: Added script that allows developers to download ``setupcfg_examples.txt`` prior to running tests. By caching these files it should be possible to run the test suite offline. v61.3.0 ======= Changes ------- * #3229: Disabled automatic download of ``trove-classifiers`` to facilitate reproducibility. Misc ---- * #3229: Updated ``pyproject.toml`` validation via ``validate-pyproject`` v0.7.1. * #3229: New internal tool made available for updating the code responsible for the validation of ``pyproject.toml``. This tool can be executed via ``tox -e generate-validation-code``. v61.2.0 ======= Changes ------- * #3215: Ignored a subgroup of invalid ``pyproject.toml`` files that use the ``[project]`` table to specify only ``requires-python`` (**transitional**). .. warning:: Please note that future releases of setuptools will halt the build process if a ``pyproject.toml`` file that does not match doc:`the PyPA Specification ` is given. * #3215: Updated ``pyproject.toml`` validation, as generated by ``validate-pyproject==0.6.1``. * #3218: Prevented builds from erroring if the project specifies metadata via ``pyproject.toml``, but uses other files (e.g. ``setup.py``) to complement it, without setting ``dynamic`` properly. .. important:: This is a **transitional** behaviour. Future releases of ``setuptools`` may simply ignore externally set metadata not backed by ``dynamic`` or even halt the build with an error. * #3224: Merge changes from pypa/distutils@e1d5c9b1f6 Documentation changes --------------------- * #3217: Fixed typo in ``pyproject.toml`` example in Quickstart -- by :user:`pablo-cardenas`. Misc ---- * #3223: Fixed missing requirements with environment markers when ``optional-dependencies`` is set in ``pyproject.toml``. v61.1.1 ======= Misc ---- * #3212: Fixed missing dependencies when running ``setup.py install``. Note that calling ``setup.py install`` directly is still deprecated and will be removed in future versions of ``setuptools``. Please check the release notes for :ref:`setup_install_deprecation_note`. v61.1.0 ======= Deprecations ------------ * #3206: Changed ``setuptools.convert_path`` to an internal function that is not exposed as part of setuptools API. Future releases of ``setuptools`` are likely to remove this function. Changes ------- * #3202: Changed behaviour of auto-discovery to not explicitly expand ``package_dir`` for flat-layouts and to not use relative paths starting with ``./``. * #3203: Prevented ``pyproject.toml`` parsing from overwriting ``dist.include_package_data`` explicitly set in ``setup.py`` with default value. * #3208: Added a warning for non existing files listed with the ``file`` directive in ``setup.cfg`` and ``pyproject.toml``. * #3208: Added a default value for dynamic ``classifiers`` in ``pyproject.toml`` when files are missing and errors being ignored. * #3211: Disabled auto-discovery when distribution class has a ``configuration`` attribute (e.g. when the ``setup.py`` script contains ``setup(..., configuration=...)``). This is done to ensure extension-only packages created with ``numpy.distutils.misc_util.Configuration`` are not broken by the safe guard behaviour to avoid accidental multiple top-level packages in a flat-layout. .. note:: Users that don't set ``packages``, ``py_modules``, or ``configuration`` are still likely to observe the auto-discovery behavior, which may halt the build if the project contains multiple directories and/or multiple Python files directly under the project root. To disable auto-discovery please explicitly set either ``packages`` or ``py_modules``. Alternatively you can also configure :ref:`custom-discovery`. v61.0.0 ======= Deprecations ------------ * #3068: Deprecated ``setuptools.config.read_configuration``, ``setuptools.config.parse_configuration`` and other functions or classes from ``setuptools.config``. Users that still need to parse and process configuration from ``setup.cfg`` can import a direct replacement from ``setuptools.config.setupcfg``, however this module is transitional and might be removed in the future (the ``setup.cfg`` configuration format itself is likely to be deprecated in the future). Breaking Changes ---------------- * #2894: If you purposefully want to create an *"empty distribution"*, please be aware that some Python files (or general folders) might be automatically detected and included. Projects that currently don't specify both ``packages`` and ``py_modules`` in their configuration and contain extra folders or Python files (not meant for distribution), might see these files being included in the wheel archive or even experience the build to fail. You can check details about the automatic discovery (and how to configure a different behaviour) in :doc:`/userguide/package_discovery`. * #3067: If the file ``pyproject.toml`` exists and it includes project metadata/config (via ``[project]`` table or ``[tool.setuptools]``), a series of new behaviors that are not backward compatible may take place: - The default value of ``include_package_data`` will be considered to be ``True``. - Setuptools will attempt to validate the ``pyproject.toml`` file according to PEP 621 specification. - The values specified in ``pyproject.toml`` will take precedence over those specified in ``setup.cfg`` or ``setup.py``. Changes ------- * #2887: **[EXPERIMENTAL]** Added automatic discovery for ``py_modules`` and ``packages`` -- by :user:`abravalheri`. Setuptools will try to find these values assuming that the package uses either the *src-layout* (a ``src`` directory containing all the packages or modules), the *flat-layout* (package directories directly under the project root), or the *single-module* approach (an isolated Python file, directly under the project root). The automatic discovery will also respect layouts that are explicitly configured using the ``package_dir`` option. For backward-compatibility, this behavior will be observed **only if both** ``py_modules`` **and** ``packages`` **are not set**. (**Note**: specifying ``ext_modules`` might also prevent auto-discover from taking place) If setuptools detects modules or packages that are not supposed to be in the distribution, please manually set ``py_modules`` and ``packages`` in your ``setup.cfg`` or ``setup.py`` file. If you are using a *flat-layout*, you can also consider switching to *src-layout*. * #2887: **[EXPERIMENTAL]** Added automatic configuration for the ``name`` metadata -- by :user:`abravalheri`. Setuptools will adopt the name of the top-level package (or module in the case of single-module distributions), **only when** ``name`` **is not explicitly provided**. Please note that it is not possible to automatically derive a single name when the distribution consists of multiple top-level packages or modules. * #3066: Added vendored dependencies for :pypi:`tomli`, :pypi:`validate-pyproject`. These dependencies are used to read ``pyproject.toml`` files and validate them. * #3067: **[EXPERIMENTAL]** When using ``pyproject.toml`` metadata, the default value of ``include_package_data`` is changed to ``True``. * #3068: **[EXPERIMENTAL]** Add support for ``pyproject.toml`` configuration (as introduced by :pep:`621`). Configuration parameters not covered by standards are handled in the ``[tool.setuptools]`` sub-table. In the future, existing ``setup.cfg`` configuration may be automatically converted into the ``pyproject.toml`` equivalent before taking effect (as proposed in #1688). Meanwhile users can use automated tools like :pypi:`ini2toml` to help in the transition. Please note that the legacy backend is not guaranteed to work with ``pyproject.toml`` configuration. -- by :user:`abravalheri` * #3125: Implicit namespaces (as introduced in :pep:`420`) are now considered by default during :doc:`package discovery `, when ``setuptools`` configuration and project metadata are added to the ``pyproject.toml`` file. To disable this behaviour, use ``namespaces = False`` when explicitly setting the ``[tool.setuptools.packages.find]`` section in ``pyproject.toml``. This change is backwards compatible and does not affect the behaviour of configuration done in ``setup.cfg`` or ``setup.py``. * #3152: **[EXPERIMENTAL]** Added support for ``attr:`` and ``cmdclass`` configurations in ``setup.cfg`` and ``pyproject.toml`` when ``package_dir`` is implicitly found via auto-discovery. * #3178: Postponed importing ``ctypes`` when hiding files on Windows. This helps to prevent errors in systems that might not have ``libffi`` installed. * #3179: Merge with pypa/distutils@267dbd25ac Documentation changes --------------------- * #3172: Added initial documentation about configuring ``setuptools`` via ``pyproject.toml`` (using standard project metadata). Misc ---- * #3065: Refactored ``setuptools.config`` by separating configuration parsing (specific to the configuration file format, e.g. ``setup.cfg``) and post-processing (which includes directives such as ``file:`` that can be used across different configuration formats). v60.10.0 ======== Changes ------- * #2971: Deprecated upload_docs command, to be removed in the future. * #3137: Use samefile from stdlib, supported on Windows since Python 3.2. * #3170: Adopt nspektr (vendored) to implement Distribution._install_dependencies. Documentation changes --------------------- * #3144: Added documentation on using console_scripts from setup.py, which was previously only shown in setup.cfg -- by :user:`xhlulu` * #3148: Added clarifications about ``MANIFEST.in``, that include links to PyPUG docs and more prominent mentions to using a revision control system plugin as an alternative. * #3148: Removed mention to ``pkg_resources`` as the recommended way of accessing data files, in favour of importlib.resources. Additionally more emphasis was put on the fact that *package data files* reside **inside** the *package directory* (and therefore should be *read-only*). Misc ---- * #3120: Added workaround for intermittent failures of backend tests on PyPy. These tests now are marked with `XFAIL `_, instead of erroring out directly. * #3124: Improved configuration for :pypi:`rst-linker` (extension used to build the changelog). * #3133: Enhanced isolation of tests using virtual environments - PYTHONPATH is not leaking to spawned subprocesses -- by :user:`befeleme` * #3147: Added options to provide a pre-built ``setuptools`` wheel or sdist for being used during tests with virtual environments. Paths for these pre-built distribution files can now be set via the environment variables: ``PRE_BUILT_SETUPTOOLS_SDIST`` and ``PRE_BUILT_SETUPTOOLS_WHEEL``. v60.9.3 ======= Misc ---- * #3093: Repaired automated release process. v60.9.2 ======= Misc ---- * #3035: When loading distutils from the vendored copy, rewrite ``__name__`` to ensure consistent importing from inside and out. v60.9.1 ======= Misc ---- * #3102: Prevent vendored importlib_metadata from loading distributions from older importlib_metadata. * #3103: Fixed issue where string-based entry points would be omitted. * #3107: Bump importlib_metadata to 4.11.1 addressing issue with parsing requirements in egg-info as found in PyPy. v60.9.0 ======= Changes ------- * #2876: In the build backend, allow single config settings to be supplied. * #2993: Removed workaround in distutils hack for get-pip now that pypa/get-pip#137 is closed. * #3085: Setuptools no longer relies on ``pkg_resources`` for entry point handling. * #3098: Bump vendored packaging to 21.3. * Removed bootstrap script. .. warning:: Users trying to install the unmaintained :pypi:`pathlib` backport from PyPI/``sdist``/source code may find problems when using ``setuptools >= 60.9.0``. This happens because during the installation, the unmaintained implementation of ``pathlib`` is loaded and may cause compatibility problems (it does not expose the same public API defined in the Python standard library). Whenever possible users should avoid declaring ``pathlib`` as a dependency. An alternative is to pre-build a wheel for ``pathlib`` using a separated virtual environment with an older version of setuptools and install the library directly from the pre-built wheel. v60.8.2 ======= Misc ---- * #3091: Make ``concurrent.futures`` import lazy in vendored ``more_itertools`` package to a avoid importing threading as a side effect (which caused `gevent/gevent#1865 `__). -- by :user:`maciejp-ro` v60.8.1 ======= Misc ---- * #3084: When vendoring jaraco packages, ensure the namespace package is converted to a simple package to support zip importer. v60.8.0 ======= Changes ------- * #3085: Setuptools now vendors importlib_resources and importlib_metadata and jaraco.text. Setuptools no longer relies on pkg_resources for ensure_directory nor parse_requirements. v60.7.1 ======= Misc ---- * #3072: Remove lorem_ipsum from jaraco.text when vendored. v60.7.0 ======= Changes ------- * #3061: Vendored jaraco.text and use line processing from that library in pkg_resources. Misc ---- * #3070: Avoid AttributeError in easy_install.create_home_path when sysconfig.get_config_vars values are not strings. v60.6.0 ======= Changes ------- * #3043: Merge with pypa/distutils@bb018f1ac3 including consolidated behavior in sysconfig.get_platform (pypa/distutils#104). * #3057: Don't include optional ``Home-page`` in metadata if no ``url`` is specified. -- by :user:`cdce8p` * #3062: Merge with pypa/distutils@b53a824ec3 including improved support for lib directories on non-x64 Windows builds. Documentation changes --------------------- * #2897: Added documentation about wrapping ``setuptools.build_meta`` in a in-tree custom backend. This is a :pep:`517`-compliant way of dynamically specifying build dependencies (e.g. when platform, OS and other markers are not enough). -- by :user:`abravalheri` * #3034: Replaced occurrences of the defunct distutils-sig mailing list with pointers to GitHub Discussions. -- by :user:`ashemedai` * #3056: The documentation has stopped suggesting to add ``wheel`` to :pep:`517` requirements -- by :user:`webknjaz` Misc ---- * #3054: Used Py3 syntax ``super().__init__()`` -- by :user:`imba-tjd` v60.5.4 ======= Misc ---- * #3009: Remove filtering of distutils warnings. * #3031: Suppress distutils replacement when building or testing CPython. v60.5.3 ======= Misc ---- * #3026: Honor sysconfig variables in easy_install. v60.5.2 ======= Misc ---- * #2993: In _distutils_hack, for get-pip, simulate existence of setuptools. v60.5.1 ======= Misc ---- * #2918: Correct support for Python 3 native loaders. v60.5.0 ======= Changes ------- * #2990: Set the ``.origin`` attribute of the ``distutils`` module to the module's ``__file__``. v60.4.0 ======= Changes ------- * #2839: Removed ``requires`` sorting when installing wheels as an egg dir. * #2953: Fixed a bug that easy install incorrectly parsed Python 3.10 version string. * #3006: Fixed startup performance issue of Python interpreter due to imports of costly modules in ``_distutils_hack`` -- by :user:`tiran` Documentation changes --------------------- * #2674: Added link to additional resources on packaging in Quickstart guide * #3008: "In-tree" Sphinx extension for "favicons" replaced with ``sphinx-favicon``. * #3008: SVG images (logo, banners, ...) optimised with the help of the ``scour`` package. Misc ---- * #2862: Added integration tests that focus on building and installing some packages in the Python ecosystem via ``pip`` -- by :user:`abravalheri` * #2952: Modified "vendoring" logic to keep license files. * #2968: Improved isolation for some tests that where inadvertently using the project root for builds, and therefore creating directories (e.g. ``build``, ``dist``, ``*.egg-info``) that could interfere with the outcome of other tests -- by :user:`abravalheri`. * #2968: Introduced new test fixtures ``venv``, ``venv_without_setuptools``, ``bare_venv`` that rely on the ``jaraco.envs`` package. These new test fixtures were also used to remove the (currently problematic) dependency on the ``pytest_virtualenv`` plugin. * #2968: Removed ``tmp_src`` test fixture. Previously this fixture was copying all the files and folders under the project root, including the ``.git`` directory, which is error prone and increases testing time. Since ``tmp_src`` was used to populate virtual environments (installing the version of ``setuptools`` under test via the source tree), it was replaced by the new ``setuptools_sdist`` and ``setuptools_wheel`` fixtures (that are build only once per session testing and can be shared between all the workers for read-only usage). v60.3.1 ======= Misc ---- * #3002: Suppress AttributeError when detecting get-pip. v60.3.0 ======= Changes ------- * #2993: In _distutils_hack, bypass the distutils exception for pip when get-pip is being invoked, because it imports setuptools. Misc ---- * #2989: Merge with pypa/distutils@788cc159. Includes fix for config vars missing from sysconfig. v60.2.0 ======= Changes ------- * #2974: Setuptools now relies on the Python logging infrastructure to log messages. Instead of using ``distutils.log.*``, use ``logging.getLogger(name).*``. * #2987: Sync with pypa/distutils@2def21c5d74fdd2fe7996ee4030ac145a9d751bd, including fix for missing get_versions attribute (#2969), more reliance on sysconfig from stdlib. Misc ---- * #2962: Avoid attempting to use local distutils when the presiding version of Setuptools on the path doesn't have one. * #2983: Restore 'add_shim' as the way to invoke the hook. Avoids compatibility issues between different versions of Setuptools with the distutils local implementation. v60.1.1 ======= Misc ---- * #2980: Bypass distutils loader when setuptools module is no longer available on sys.path. v60.1.0 ======= Changes ------- * #2958: In distutils_hack, only add the metadata finder once. In ensure_local_distutils, rely on a context manager for reliable manipulation. * #2963: Merge with pypa/distutils@a5af364910. Includes revisited fix for pypa/distutils#15 and improved MinGW/Cygwin support from pypa/distutils#77. v60.0.5 ======= Misc ---- * #2960: Install schemes fall back to default scheme for headers. v60.0.4 ======= Misc ---- * #2954: Merge with pypa/distutils@eba2bcd310. Adds platsubdir to config vars available for substitution. v60.0.3 ======= Misc ---- * #2940: Avoid KeyError in distutils hack when pip is imported during ensurepip. v60.0.2 ======= Misc ---- * #2938: Select 'posix_user' for the scheme unless falling back to stdlib, then use 'unix_user'. v60.0.1 ======= Misc ---- * #2944: Add support for extended install schemes in easy_install. v60.0.0 ======= Breaking Changes ---------------- * #2896: Setuptools once again makes its local copy of distutils the default. To override, set SETUPTOOLS_USE_DISTUTILS=stdlib. v59.8.0 ======= Changes ------- * #2935: Merge pypa/distutils@460b59f0e68dba17e2465e8dd421bbc14b994d1f. v59.7.0 ======= Changes ------- * #2930: Require Python 3.7 v59.6.0 ======= Changes ------- * #2925: Merge with pypa/distutils@92082ee42c including introduction of deprecation warning on Version classes. v59.5.0 ======= Changes ------- * #2914: Merge with pypa/distutils@8f2df0bf6. v59.4.0 ======= Changes ------- * #2893: Restore deprecated support for newlines in the Summary field. v59.3.0 ======= Changes ------- * #2902: Merge with pypa/distutils@85db7a41242. Misc ---- * #2906: In ensure_local_distutils, re-use DistutilsMetaFinder to load the module. Avoids race conditions when _distutils_system_mod is employed. v59.2.0 ======= Changes ------- * #2875: Introduce changes from pypa/distutils@514e9d0, including support for overrides from Debian and pkgsrc, unlocking the possibility of making SETUPTOOLS_USE_DISTUTILS=local the default again. v59.1.1 ======= Misc ---- * #2885: Fixed errors when encountering LegacyVersions. v59.1.0 ======= Changes ------- * #2497: Update packaging to 21.2. * #2877: Back out deprecation of setup_requires and replace instead by a deprecation of setuptools.installer and fetch_build_egg. Now setup_requires is still supported when installed as part of a PEP 517 build, but is deprecated when an unsatisfied requirement is encountered. * #2879: Bump packaging to 21.2. Documentation changes --------------------- * #2867: PNG/ICO images replaced with SVG in the docs. * #2867: Added support to SVG "favicons" via "in-tree" Sphinx extension. v59.0.1 ======= Misc ---- * #2880: Removed URL requirement for ``pytest-virtualenv`` in ``setup.cfg``. PyPI rejects packages with dependencies external to itself. Instead the test dependency was overwritten via ``tox.ini`` v59.0.0 ======= Deprecations ------------ * #2856: Support for custom commands that inherit directly from ``distutils`` is **deprecated**. Users should extend classes provided by setuptools instead. Breaking Changes ---------------- * #2870: Started failing on invalid inline description with line breaks :class:`ValueError` -- by :user:`webknjaz` Changes ------- * #2698: Exposed exception classes from ``distutils.errors`` via ``setuptools.errors``. * #2866: Incorporate changes from pypa/distutils@f1b0a2b. Documentation changes --------------------- * #2227: Added sphinx theme customisations to display the new logo in the sidebar and use its colours as "accent" in the documentation -- by :user:`abravalheri` * #2227: Added new setuptools logo, including editable files and artwork documentation -- by :user:`abravalheri` * #2698: Added mentions to ``setuptools.errors`` as a way of handling custom command errors. * #2698: Added instructions to migrate from ``distutils.commands`` and ``distutils.errors`` in the porting guide. * #2871: Added a note to the docs that it is possible to install ``setup.py``-less projects in editable mode with :doc:`pip v21.1+ `, only having ``setup.cfg`` and ``pyproject.toml`` in project root -- by :user:`webknjaz` v58.5.3 ======= Misc ---- * #2849: Add fallback for custom ``build_py`` commands inheriting directly from :mod:`distutils`, while still handling ``include_package_data=True`` for ``sdist``. v58.5.2 ======= Misc ---- * #2847: Suppress 'setup.py install' warning under bdist_wheel. v58.5.1 ======= Misc ---- * #2846: Move PkgResourcesDeprecationWarning above implicitly-called function so that it's in the namespace when version warnings are generated in an environment that contains them. v58.5.0 ======= Changes ------- * #1461: Fix inconsistency with ``include_package_data`` and ``packages_data`` in sdist by replacing the loop breaking mechanism between the ``sdist`` and ``egg_info`` commands -- by :user:`abravalheri` v58.4.0 ======= Changes ------- * #2497: Officially deprecated PEP 440 non-compliant versions. Documentation changes --------------------- * #2832: Removed the deprecated ``data_files`` option from the example in the declarative configuration docs -- by :user:`abravalheri` * #2832: Change type of ``data_files`` option from ``dict`` to ``section`` in declarative configuration docs (to match previous example) -- by :user:`abravalheri` .. _setup_install_deprecation_note: v58.3.0 ======= Changes ------- * #917: ``setup.py install`` and ``easy_install`` commands are now officially deprecated. Use other standards-based installers (like pip) and builders (like build). Workloads reliant on this behavior should pin to this major version of Setuptools. See `Why you shouldn't invoke setup.py directly `_ for more background. * #1988: Deprecated the ``bdist_rpm`` command. Binary packages should be built as wheels instead. -- by :user:`hugovk` * #2785: Replace ``configparser``'s ``readfp`` with ``read_file``, deprecated since Python 3.2. -- by :user:`hugovk` * #2823: Officially deprecated support for ``setup_requires``. Users are encouraged instead to migrate to PEP 518 ``build-system.requires`` in ``pyproject.toml``. Users reliant on ``setup_requires`` should consider pinning to this major version to avoid disruption. Misc ---- * #2762: Changed codecov.yml to configure the threshold to be lower -- by :user:`tanvimoharir` v58.2.0 ======= Changes ------- * #2757: Add windows arm64 launchers for scripts generated by easy_install. * #2800: Added ``--owner`` and ``--group`` options to the ``sdist`` command, for specifying file ownership within the produced tarball (similarly to the corresponding distutils ``sdist`` options). Documentation changes --------------------- * #2792: Document how the legacy and non-legacy versions are compared, and reference to the PEP 440 scheme. v58.1.0 ======= Changes ------- * #2796: Merge with pypa/distutils@02e9f65ab0 v58.0.4 ======= Misc ---- * #2773: Retain case in setup.cfg during sdist. v58.0.3 ======= Misc ---- * #2777: Build does not fail fast when ``use_2to3`` is supplied but set to a false value. v58.0.2 ======= Misc ---- * #2769: Build now fails fast when ``use_2to3`` is supplied. v58.0.1 ======= Misc ---- * #2765: In Distribution.finalize_options, suppress known removed entry points to avoid issues with older Setuptools. v58.0.0 ======= Breaking Changes ---------------- * #2086: Removed support for 2to3 during builds. Projects should port to a unified codebase or pin to an older version of Setuptools using PEP 518 build-requires. Documentation changes --------------------- * #2746: add python_requires example v57.5.0 ======= Changes ------- * #2712: Added implicit globbing support for ``[options.data_files]`` values. Documentation changes --------------------- * #2737: fix various syntax and style errors in code snippets in docs v57.4.0 ======= Changes ------- * #2722: Added support for ``SETUPTOOLS_EXT_SUFFIX`` environment variable to override the suffix normally detected from the ``sysconfig`` module. v57.3.0 ======= Changes ------- * #2465: Documentation is now published using the Furo theme. v57.2.0 ======= Changes ------- * #2724: Added detection of Windows ARM64 build environments using the ``VSCMD_ARG_TGT_ARCH`` environment variable. v57.1.0 ======= Changes ------- * #2692: Globs are now sorted in 'license_files' restoring reproducibility by eliminating variance from disk order. * #2714: Update to distutils at pypa/distutils@e2627b7. * #2715: Removed reliance on deprecated ssl.match_hostname by removing the ssl support. Now any index operations rely on the native SSL implementation. Documentation changes --------------------- * #2604: Revamped the backward/cross tool compatibility section to remove some confusion. Add some examples and the version since when ``entry_points`` are supported in declarative configuration. Tried to make the reading flow a bit leaner, gather some information that were a bit dispersed. v57.0.0 ======= Breaking Changes ---------------- * #2645: License files excluded via the ``MANIFEST.in`` but matched by either the ``license_file`` (deprecated) or ``license_files`` options, will be nevertheless included in the source distribution. - by :user:`cdce8p` Changes ------- * #2628: Write long description in message payload of PKG-INFO file. - by :user:`cdce8p` * #2645: Added ``License-File`` (multiple) to the output package metadata. The field will contain the path of a license file, matched by the ``license_file`` (deprecated) and ``license_files`` options, relative to ``.dist-info``. - by :user:`cdce8p` * #2678: Moved Setuptools' own entry points into declarative config. * #2680: Vendored :pypi:`more_itertools` for Setuptools. * #2681: Setuptools own setup.py no longer declares setup_requires, but instead expects wheel to be installed as declared by pyproject.toml. Misc ---- * #2650: Updated the docs build tooling to support the latest version of Towncrier and show the previews of not-yet-released setuptools versions in the changelog -- :user:`webknjaz` v56.2.0 ======= Changes ------- * #2640: Fixed handling of multiline license strings. - by :user:`cdce8p` * #2641: Setuptools will now always try to use the latest supported metadata version for ``PKG-INFO``. - by :user:`cdce8p` v56.1.0 ======= Changes ------- * #2653: Incorporated assorted changes from pypa/distutils. * #2657: Adopted docs from distutils. * #2663: Added Visual Studio Express 2017 support -- by :user:`dofuuz` Misc ---- * #2644: Fixed ``DeprecationWarning`` due to ``threading.Thread.setDaemon`` in tests -- by :user:`tirkarthi` * #2654: Made the changelog generator compatible with Towncrier >= 19.9 -- :user:`webknjaz` * #2664: Relax the deprecation message in the distutils hack. v56.0.0 ======= Deprecations ------------ * #2620: The ``license_file`` option is now marked as deprecated. Use ``license_files`` instead. -- by :user:`cdce8p` Breaking Changes ---------------- * #2620: If neither ``license_file`` nor ``license_files`` is specified, the ``sdist`` option will now auto-include files that match the following patterns: ``LICEN[CS]E*``, ``COPYING*``, ``NOTICE*``, ``AUTHORS*``. This matches the behavior of ``bdist_wheel``. -- by :user:`cdce8p` Changes ------- * #2620: The ``license_file`` and ``license_files`` options now support glob patterns. -- by :user:`cdce8p` * #2632: Implemented ``VendorImporter.find_spec()`` method to get rid of ``ImportWarning`` that Python 3.10 emits when only the old-style importer hooks are present -- by :user:`webknjaz` Documentation changes --------------------- * #2620: Added documentation for the ``license_files`` option. -- by :user:`cdce8p` v55.0.0 ======= Breaking Changes ---------------- * #2566: Remove the deprecated ``bdist_wininst`` command. Binary packages should be built as wheels instead. -- by :user:`hroncok` v54.2.0 ======= Changes ------- * #2608: Added informative error message to PEP 517 build failures owing to an empty ``setup.py`` -- by :user:`layday` v54.1.3 ======= No significant changes. v54.1.2 ======= Misc ---- * #2595: Reduced scope of dash deprecation warning to Setuptools/distutils only -- by :user:`melissa-kun-li` v54.1.1 ======= Documentation changes --------------------- * #2584: Added ``sphinx-inline-tabs`` extension to allow for comparison of ``setup.py`` and its equivalent ``setup.cfg`` -- by :user:`amy-lei` Misc ---- * #2592: Made option keys in the ``[metadata]`` section of ``setup.cfg`` case-sensitive. Users having uppercase option spellings will get a warning suggesting to make them to lowercase -- by :user:`melissa-kun-li` v54.1.0 ======= Changes ------- * #1608: Removed the conversion of dashes to underscores in the :code:`extras_require` and :code:`data_files` of :code:`setup.cfg` to support the usage of dashes. Method will warn users when they use a dash-separated key which in the future will only allow an underscore. Note: the method performs the dash to underscore conversion to preserve compatibility, but future versions will no longer support it -- by :user:`melissa-kun-li` v54.0.0 ======= Breaking Changes ---------------- * #2582: Simplified build-from-source story by providing bootstrapping metadata in a separate egg-info directory. Build requirements no longer include setuptools itself. Sdist once again includes the pyproject.toml. Project can no longer be installed from source on pip 19.x, but install from source is still supported on pip < 19 and pip >= 20 and install from wheel is still supported with pip >= 9. Changes ------- * #1932: Handled :code:`AttributeError` by raising :code:`DistutilsSetupError` in :code:`dist.check_specifier()` when specifier is not a string -- by :user:`melissa-kun-li` * #2570: Correctly parse cmdclass in setup.cfg. Documentation changes --------------------- * #2553: Added userguide example for markers in extras_require -- by :user:`pwoolvett` v53.1.0 ======= Changes ------- * #1937: Preserved case-sensitivity of keys in setup.cfg so that entry point names are case-sensitive. Changed sensitivity of configparser. NOTE: Any projects relying on case-insensitivity will need to adapt to accept the original case as published. -- by :user:`melissa-kun-li` * #2573: Fixed error in uploading a Sphinx doc with the :code:`upload_docs` command. An html builder will be used. Note: :code:`upload_docs` is deprecated for PyPi, but is supported for other sites -- by :user:`melissa-kun-li` v53.0.0 ======= Breaking Changes ---------------- * #1527: Removed bootstrap script. Now Setuptools requires pip or another pep517-compliant builder such as 'build' to build. Now Setuptools can be installed from Github main branch. v52.0.0 ======= Breaking Changes ---------------- * #2537: Remove fallback support for fetch_build_eggs using easy_install. Now pip is required for setup_requires to succeed. * #2544: Removed 'easy_install' top-level model (runpy entry point) and 'easy_install' console script. * #2545: Removed support for eggsecutables. Changes ------- * #2459: Tests now run in parallel via pytest-xdist, completing in about half the time. Special thanks to :user:`webknjaz` for hard work implementing test isolation. To run without parallelization, disable the plugin with ``tox -- -p no:xdist``. v51.3.3 ======= Misc ---- * #2539: Fix AttributeError in Description validation. v51.3.2 ======= Misc ---- * #1390: Validation of Description field now is more lenient, emitting a warning and mangling the value to be valid (replacing newlines with spaces). v51.3.1 ======= Misc ---- * #2536: Reverted tag deduplication handling. v51.3.0 ======= Changes ------- * #1390: Newlines in metadata description/Summary now trigger a ValueError. * #2481: Define ``create_module()`` and ``exec_module()`` methods in ``VendorImporter`` to get rid of ``ImportWarning`` -- by :user:`hroncok` * #2489: ``pkg_resources`` behavior for zipimport now matches the regular behavior, and finds ``.egg-info`` (previously would only find ``.dist-info``) -- by :user:`thatch` * #2529: Fixed an issue where version tags may be added multiple times v51.2.0 ======= Changes ------- * #2493: Use importlib.import_module() rather than the deprecated loader.load_module() in pkg_resources namespace declaration -- by :user:`encukou` Documentation changes --------------------- * #2525: Fix typo in the document page about entry point. -- by :user:`jtr109` Misc ---- * #2534: Avoid hitting network during test_easy_install. v51.1.2 ======= Misc ---- * #2505: Disable inclusion of package data as it causes 'tests' to be included as data. v51.1.1 ======= Misc ---- * #2534: Avoid hitting network during test_virtualenv.test_test_command. v51.1.0 ======= Changes ------- * #2486: Project adopts jaraco/skeleton for shared package maintenance. Misc ---- * #2477: Restore inclusion of rst files in sdist. * #2484: Setuptools has replaced the master branch with the main branch. * #2485: Fixed failing test when pip 20.3+ is present. -- by :user:`yan12125` * #2487: Fix tests with pytest 6.2 -- by :user:`yan12125` v51.0.0 ======= Breaking Changes ---------------- * #2435: Require Python 3.6 or later. Documentation changes --------------------- * #2430: Fixed inconsistent RST title nesting levels caused by #2399 -- by :user:`webknjaz` * #2430: Fixed a typo in Sphinx docs that made docs dev section disappear as a result of PR #2426 -- by :user:`webknjaz` Misc ---- * #2471: Removed the tests that guarantee that the vendored dependencies can be built by distutils. v50.3.2 ======= Documentation changes --------------------- * #2394: Extended towncrier news template to include change note categories. This allows to see what types of changes a given version introduces -- by :user:`webknjaz` * #2427: Started enforcing strict syntax and reference validation in the Sphinx docs -- by :user:`webknjaz` * #2428: Removed redundant Sphinx ``Makefile`` support -- by :user:`webknjaz` Misc ---- * #2401: Enabled test results reporting in AppVeyor CI -- by :user:`webknjaz` * #2420: Replace Python 3.9.0 beta with 3.9.0 final on GitHub Actions. * #2421: Python 3.9 Trove classifier got added to the dist metadata -- by :user:`webknjaz` v50.3.1 ======= Documentation changes --------------------- * #2093: Finalized doc revamp. * #2097: doc: simplify index and group deprecated files * #2102: doc overhaul step 2: break main doc into multiple sections * #2111: doc overhaul step 3: update userguide * #2395: Added a ``:user:`` role to Sphinx config -- by :user:`webknjaz` * #2395: Added an illustrative explanation about the change notes to fragments dir -- by :user:`webknjaz` Misc ---- * #2379: Travis CI test suite now tests against PPC64. * #2413: Suppress EOF errors (and other exceptions) when importing lib2to3. v50.3.0 ======= Changes ------- * #2368: In distutils, restore support for monkeypatched CCompiler.spawn per pypa/distutils#15. v50.2.0 ======= Changes ------- * #2355: When pip is imported as part of a build, leave distutils patched. * #2380: There are some setuptools specific changes in the ``setuptools.command.bdist_rpm`` module that are no longer needed, because they are part of the ``bdist_rpm`` module in distutils in Python 3.5.0. Therefore, code was removed from ``setuptools.command.bdist_rpm``. v50.1.0 ======= Changes ------- * #2350: Setuptools reverts using the included distutils by default. Platform maintainers and system integrators and others are *strongly* encouraged to set ``SETUPTOOLS_USE_DISTUTILS=local`` to help identify and work through the reported issues with distutils adoption, mainly to file issues and pull requests with pypa/distutils such that distutils performs as needed across every supported environment. v50.0.3 ======= Misc ---- * #2363: Restore link_libpython support on Python 3.7 and earlier (see pypa/distutils#9). v50.0.2 ======= Misc ---- * #2352: In distutils hack, use absolute import rather than relative to avoid bpo-30876. v50.0.1 ======= Misc ---- * #2357: Restored Python 3.5 support in distutils.util for missing ``subprocess._optim_args_from_interpreter_flags``. * #2358: Restored AIX support on Python 3.8 and earlier. * #2361: Add Python 3.10 support to _distutils_hack. Get the 'Loader' abstract class from importlib.abc rather than importlib.util.abc (alias removed in Python 3.10). v50.0.0 ======= Breaking Changes ---------------- * #2232: Once again, Setuptools overrides the stdlib distutils on import. For environments or invocations where this behavior is undesirable, users are provided with a temporary escape hatch. If the environment variable ``SETUPTOOLS_USE_DISTUTILS`` is set to ``stdlib``, Setuptools will fall back to the legacy behavior. Use of this escape hatch is discouraged, but it is provided to ease the transition while proper fixes for edge cases can be addressed. Changes ------- * #2334: In MSVC module, refine text in error message. v49.6.0 ======= Changes ------- * #2129: In pkg_resources, no longer detect any pathname ending in .egg as a Python egg. Now the path must be an unpacked egg or a zip file. v49.5.0 ======= Changes ------- * #2306: When running as a PEP 517 backend, setuptools does not try to install ``setup_requires`` itself. They are reported as build requirements for the frontend to install. v49.4.0 ======= Changes ------- * #2310: Updated vendored packaging version to 20.4. v49.3.2 ======= Documentation changes --------------------- * #2300: Improve the ``safe_version`` function documentation Misc ---- * #2297: Once again, in stubs prefer exec_module to the deprecated load_module. v49.3.1 ======= Changes ------- * #2316: Removed warning when ``distutils`` is imported before ``setuptools`` when ``distutils`` replacement is not enabled. v49.3.0 ======= Changes ------- * #2259: Setuptools now provides a .pth file (except for editable installs of setuptools) to the target environment to ensure that when enabled, the setuptools-provided distutils is preferred before setuptools has been imported (and even if setuptools is never imported). Honors the SETUPTOOLS_USE_DISTUTILS environment variable. v49.2.1 ======= Misc ---- * #2257: Fixed two flaws in distutils._msvccompiler.MSVCCompiler.spawn. v49.2.0 ======= Changes ------- * #2230: Now warn the user when setuptools is imported after distutils modules have been loaded (exempting PyPy for 3.6), directing the users of packages to import setuptools first. v49.1.3 ======= Misc ---- * #2212: (Distutils) Allow spawn to accept environment. Avoid monkey-patching global state. * #2249: Fix extension loading technique in stubs. v49.1.2 ======= Changes ------- * #2232: In preparation for re-enabling a local copy of distutils, Setuptools now honors an environment variable, SETUPTOOLS_USE_DISTUTILS. If set to 'stdlib' (current default), distutils will be used from the standard library. If set to 'local' (default in a imminent backward-incompatible release), the local copy of distutils will be used. v49.1.1 ======= Misc ---- * #2094: Removed pkg_resources.py2_warn module, which is no longer reachable. v49.0.1 ======= Misc ---- * #2228: Applied fix for pypa/distutils#3, restoring expectation that spawn will raise a DistutilsExecError when attempting to execute a missing file. v49.1.0 ======= Changes ------- * #2228: Disabled distutils adoption for now while emergent issues are addressed. v49.0.0 ======= Breaking Changes ---------------- * #2165: Setuptools no longer installs a site.py file during easy_install or develop installs. As a result, .eggs on PYTHONPATH will no longer take precedence over other packages on sys.path. If this issue affects your production environment, please reach out to the maintainers at #2165. Changes ------- * #2137: Removed (private) pkg_resources.RequirementParseError, now replaced by packaging.requirements.InvalidRequirement. Kept the name for compatibility, but users should catch InvalidRequirement instead. * #2180: Update vendored packaging in pkg_resources to 19.2. Misc ---- * #2199: Fix exception causes all over the codebase by using ``raise new_exception from old_exception`` v48.0.0 ======= Breaking Changes ---------------- * #2143: Setuptools adopts distutils from the Python 3.9 standard library and no longer depends on distutils in the standard library. When importing ``setuptools`` or ``setuptools.distutils_patch``, Setuptools will expose its bundled version as a top-level ``distutils`` package (and unload any previously-imported top-level distutils package), retaining the expectation that ``distutils``' objects are actually Setuptools objects. To avoid getting any legacy behavior from the standard library, projects are advised to always "import setuptools" prior to importing anything from distutils. This behavior happens by default when using ``pip install`` or ``pep517.build``. Workflows that rely on ``setup.py (anything)`` will need to first ensure setuptools is imported. One way to achieve this behavior without modifying code is to invoke Python thus: ``python -c "import setuptools; exec(open('setup.py').read())" (anything)``. v47.3.2 ======= Misc ---- * #2071: Replaced references to the deprecated imp package with references to importlib v47.3.1 ======= Misc ---- * #1973: Removed ``pkg_resources.py31compat.makedirs`` in favor of the stdlib. Use ``os.makedirs()`` instead. * #2198: Restore ``__requires__`` directive in easy-install wrapper scripts. v47.3.0 ======= Changes ------- * #2197: Console script wrapper for editable installs now has a unified template and honors importlib_metadata if present for faster script execution on older Pythons. Misc ---- * #2195: Fix broken entry points generated by easy-install (pip editable installs). v47.2.0 ======= Changes ------- * #2194: Editable-installed entry points now load significantly faster on Python versions 3.8+. * #1471: Incidentally fixed by #2194 on Python 3.8 or when importlib_metadata is present. v47.1.1 ======= Documentation changes --------------------- * #2156: Update mailing list pointer in developer docs Incorporate changes from v44.1.1: --------------------------------- * #2158: Avoid loading working set during ``Distribution.finalize_options`` prior to invoking ``_install_setup_requires``, broken since v42.0.0. v44.1.1 ======= Misc ---- * #2158: Avoid loading working set during ``Distribution.finalize_options`` prior to invoking ``_install_setup_requires``, broken since v42.0.0. v47.1.0 ======= Changes ------- * #2070: In wheel-to-egg conversion, use simple pkg_resources-style namespace declaration for packages that declare namespace_packages. v47.0.0 ======= Breaking Changes ---------------- * #2094: Setuptools now actively crashes under Python 2. Python 3.5 or later is required. Users of Python 2 should use ``setuptools<45``. Changes ------- * #1700: Document all supported keywords by migrating the ones from distutils. v46.4.0 ======= Changes ------- * #1753: ``attr:`` now extracts variables through rudimentary examination of the AST, thereby supporting modules with third-party imports. If examining the AST fails to find the variable, ``attr:`` falls back to the old behavior of importing the module. Works on Python 3 only. v46.3.1 ======= No significant changes. v46.3.0 ======= Changes ------- * #2089: Package index functionality no longer attempts to remove an md5 fragment from the index URL. This functionality, added for distribute #163 is no longer relevant. Misc ---- * #2041: Preserve file modes during pkg files copying, but clear read only flag for target afterwards. * #2105: Filter ``2to3`` deprecation warnings from ``TestDevelop.test_2to3_user_mode``. v46.2.0 ======= Changes ------- * #2040: Deprecated the ``bdist_wininst`` command. Binary packages should be built as wheels instead. * #2062: Change 'Mac OS X' to 'macOS' in code. * #2075: Stop recognizing files ending with ``.dist-info`` as distribution metadata. * #2086: Deprecate 'use_2to3' functionality. Packagers are encouraged to use single-source solutions or build tool chains to manage conversions outside of setuptools. Documentation changes --------------------- * #1698: Added documentation for ``build_meta`` (a bare minimum, not completed). Misc ---- * #2082: Filter ``lib2to3`` ``PendingDeprecationWarning`` and ``DeprecationWarning`` in tests, because ``lib2to3`` is `deprecated in Python 3.9 `_. v46.1.3 ======= No significant changes. v46.1.2 ======= Misc ---- * #1458: Added template for reporting Python 2 incompatibilities. v46.1.1 ======= No significant changes. v46.1.0 ======= Changes ------- * #308: Allow version number normalization to be bypassed by wrapping in a 'setuptools.sic()' call. * #1424: Prevent keeping files mode for package_data build. It may break a build if user's package data has read only flag. * #1431: In ``easy_install.check_site_dir``, ensure the installation directory exists. * #1563: In ``pkg_resources`` prefer ``find_spec`` (PEP 451) to ``find_module``. Incorporate changes from v44.1.0: --------------------------------- * #1704: Set sys.argv[0] in setup script run by build_meta.__legacy__ * #1959: Fix for Python 4: replace unsafe six.PY3 with six.PY2 * #1994: Fixed a bug in the "setuptools.finalize_distribution_options" hook that lead to ignoring the order attribute of entry points managed by this hook. v44.1.0 ======= Changes ------- * #1704: Set sys.argv[0] in setup script run by build_meta.__legacy__ * #1959: Fix for Python 4: replace unsafe six.PY3 with six.PY2 * #1994: Fixed a bug in the "setuptools.finalize_distribution_options" hook that lead to ignoring the order attribute of entry points managed by this hook. v46.0.0 ======= Breaking Changes ---------------- * #65: Once again as in 3.0, removed the Features feature. Changes ------- * #1890: Fix vendored dependencies so importing ``setuptools.extern.some_module`` gives the same object as ``setuptools._vendor.some_module``. This makes Metadata picklable again. * #1899: Test suite now fails on warnings. Documentation changes --------------------- * #2011: Fix broken link to distutils docs on package_data Misc ---- * #1991: Include pkg_resources test data in sdist, so tests can be executed from it. v45.3.0 ======= Changes ------- * #1557: Deprecated eggsecutable scripts and updated docs. * #1904: Update msvc.py to use CPython 3.8.0 mechanism to find msvc 14+ v45.2.0 ======= Changes ------- * #1905: Fixed defect in _imp, introduced in 41.6.0 when the 'tests' directory is not present. * #1941: Improve editable installs with PEP 518 build isolation: * The ``--user`` option is now always available. A warning is issued if the user site directory is not available. * The error shown when the install directory is not in ``PYTHONPATH`` has been turned into a warning. * #1981: Setuptools now declares its ``tests`` and ``docs`` dependencies in metadata (extras). * #1985: Add support for installing scripts in environments where bdist_wininst is missing (i.e. Python 3.9). Misc ---- * #1968: Add flake8-2020 to check for misuse of sys.version or sys.version_info. v45.1.0 ======= Changes ------- * #1458: Add minimum sunset date and preamble to Python 2 warning. * #1704: Set sys.argv[0] in setup script run by build_meta.__legacy__ * #1974: Add Python 3 Only Trove Classifier and remove universal wheel declaration for more complete transition from Python 2. v45.0.0 ======= Breaking Changes ---------------- * #1458: Drop support for Python 2. Setuptools now requires Python 3.5 or later. Install setuptools using pip >=9 or pin to Setuptools <45 to maintain 2.7 support. Changes ------- * #1959: Fix for Python 4: replace unsafe six.PY3 with six.PY2 v44.0.0 ======= Breaking Changes ---------------- * #1908: Drop support for Python 3.4. v43.0.0 ======= Breaking Changes ---------------- * #1634: Include ``pyproject.toml`` in source distribution by default. Projects relying on the previous behavior where ``pyproject.toml`` was excluded by default should stop relying on that behavior or add ``exclude pyproject.toml`` to their MANIFEST.in file. Changes ------- * #1927: Setuptools once again declares 'setuptools' in the ``build-system.requires`` and adds PEP 517 build support by declaring itself as the ``build-backend``. It additionally specifies ``build-system.backend-path`` to rely on itself for those builders that support it. v42.0.2 ======= Changes ------- * #1921: Fix support for easy_install's ``find-links`` option in ``setup.cfg``. * #1922: Build dependencies (setup_requires and tests_require) now install transitive dependencies indicated by extras. v42.0.1 ======= Changes ------- * #1918: Fix regression in handling wheels compatibility tags. v42.0.0 ======= Breaking Changes ---------------- * #1830, #1909: Mark the easy_install script and setuptools command as deprecated, and use `pip `_ when available to fetch/build wheels for missing ``setup_requires``/``tests_require`` requirements, with the following differences in behavior: * support for ``python_requires`` * better support for wheels (proper handling of priority with respect to PEP 425 tags) * PEP 517/518 support * eggs are not supported * no support for the ``allow_hosts`` easy_install option (``index_url``/``find_links`` are still honored) * pip environment variables are honored (and take precedence over easy_install options) * #1898: Removed the "upload" and "register" commands in favor of :pypi:`twine`. Changes ------- * #1767: Add support for the ``license_files`` option in ``setup.cfg`` to automatically include multiple license files in a source distribution. * #1829: Update handling of wheels compatibility tags: * add support for manylinux2010 * fix use of removed 'm' ABI flag in Python 3.8 on Windows * #1861: Fix empty namespace package installation from wheel. * #1877: Setuptools now exposes a new entry point hook "setuptools.finalize_distribution_options", enabling plugins like :pypi:`setuptools_scm` to configure options on the distribution at finalization time. v41.6.0 ======= Changes ------- * #479: Replace usage of deprecated ``imp`` module with local re-implementation in ``setuptools._imp``. v41.5.1 ======= Changes ------- * #1891: Fix code for detecting Visual Studio's version on Windows under Python 2. v41.5.0 ======= Changes ------- * #1811: Improve Visual C++ 14.X support, mainly for Visual Studio 2017 and 2019. * #1814: Fix ``pkg_resources.Requirement`` hash/equality implementation: take PEP 508 direct URL into account. * #1824: Fix tests when running under ``python3.10``. * #1878: Formally deprecated the ``test`` command, with the recommendation that users migrate to ``tox``. Documentation changes --------------------- * #1860: Update documentation to mention the egg format is not supported by pip and dependency links support was dropped starting with pip 19.0. * #1862: Drop ez_setup documentation: deprecated for some time (last updated in 2016), and still relying on easy_install (deprecated too). * #1868: Drop most documentation references to (deprecated) EasyInstall. * #1884: Added a trove classifier to document support for Python 3.8. Misc ---- * #1886: Added Python 3.8 release to the Travis test matrix. v41.4.0 ======= Changes ------- * #1847: In declarative config, now traps errors when invalid ``python_requires`` values are supplied. v41.3.0 ======= Changes ------- * #1690: When storing extras, rely on OrderedSet to retain order of extras as indicated by the packager, which will also be deterministic on Python 2.7 (with PYTHONHASHSEED unset) and Python 3.6+. Misc ---- * #1858: Fixed failing integration test triggered by 'long_description_content_type' in packaging. v41.2.0 ======= Changes ------- * #479: Remove some usage of the deprecated ``imp`` module. Misc ---- * #1565: Changed html_sidebars from string to list of string as per https://www.sphinx-doc.org/en/master/changes.html#id58 v41.1.0 ======= Misc ---- * #1697: Moved most of the constants from setup.py to setup.cfg * #1749: Fixed issue with the PEP 517 backend where building a source distribution would fail if any tarball existed in the destination directory. * #1750: Fixed an issue with PEP 517 backend where wheel builds would fail if the destination directory did not already exist. * #1756: Force metadata-version >= 1.2. when project urls are present. * #1769: Improve ``package_data`` check: ensure the dictionary values are lists/tuples of strings. * #1788: Changed compatibility fallback logic for ``html.unescape`` to avoid accessing ``HTMLParser.unescape`` when not necessary. ``HTMLParser.unescape`` is deprecated and will be removed in Python 3.9. * #1790: Added the file path to the error message when a ``UnicodeDecodeError`` occurs while reading a metadata file. Documentation changes --------------------- * #1776: Use license classifiers rather than the license field. v41.0.1 ======= Changes ------- * #1671: Fixed issue with the PEP 517 backend that prevented building a wheel when the ``dist/`` directory contained existing ``.whl`` files. * #1709: In test.paths_on_python_path, avoid adding unnecessary duplicates to the PYTHONPATH. * #1741: In package_index, now honor "current directory" during a checkout of git and hg repositories under Windows v41.0.0 ======= Breaking Changes ---------------- * #1735: When parsing setup.cfg files, setuptools now requires the files to be encoded as UTF-8. Any other encoding will lead to a UnicodeDecodeError. This change removes support for specifying an encoding using a 'coding: ' directive in the header of the file, a feature that was introduces in 40.7. Given the recent release of the aforementioned feature, it is assumed that few if any projects are utilizing the feature to specify an encoding other than UTF-8. v40.9.0 ======= Changes ------- * #1675: Added support for ``setup.cfg``-only projects when using the ``setuptools.build_meta`` backend. Projects that have enabled PEP 517 no longer need to have a ``setup.py`` and can use the purely declarative ``setup.cfg`` configuration file instead. * #1720: Added support for ``pkg_resources.parse_requirements``-style requirements in ``setup_requires`` when ``setup.py`` is invoked from the ``setuptools.build_meta`` build backend. * #1664: Added the path to the ``PKG-INFO`` or ``METADATA`` file in the exception text when the ``Version:`` header can't be found. Documentation changes --------------------- * #1705: Removed some placeholder documentation sections referring to deprecated features. v40.8.0 ======= Changes ------- * #1652: Added the ``build_meta:__legacy__`` backend, a "compatibility mode" PEP 517 backend that can be used as the default when ``build-backend`` is left unspecified in ``pyproject.toml``. * #1635: Resource paths are passed to ``pkg_resources.resource_string`` and similar no longer accept paths that traverse parents, that begin with a leading ``/``. Violations of this expectation raise DeprecationWarnings and will become errors. Additionally, any paths that are absolute on Windows are strictly disallowed and will raise ValueErrors. * #1536: ``setuptools`` will now automatically include licenses if ``setup.cfg`` contains a ``license_file`` attribute, unless this file is manually excluded inside ``MANIFEST.in``. v40.7.3 ======= Changes ------- * #1670: In package_index, revert to using a copy of splituser from Python 3.8. Attempts to use ``urllib.parse.urlparse`` led to problems as reported in #1663 and #1668. This change serves as an alternative to #1499 and fixes #1668. v40.7.2 ======= Changes ------- * #1666: Restore port in URL handling in package_index. v40.7.1 ======= Changes ------- * #1660: On Python 2, when reading config files, downcast options from text to bytes to satisfy distutils expectations. v40.7.0 ======= Breaking Changes ---------------- * #1551: File inputs for the ``license`` field in ``setup.cfg`` files now explicitly raise an error. Changes ------- * #1180: Add support for non-ASCII in setup.cfg (#1062). Add support for native strings on some parameters (#1136). * #1499: ``setuptools.package_index`` no longer relies on the deprecated ``urllib.parse.splituser`` per Python #27485. * #1544: Added tests for PackageIndex.download (for git URLs). * #1625: In PEP 517 build_meta builder, ensure that sdists are built as gztar per the spec. v40.6.3 ======= Changes ------- * #1594: PEP 517 backend no longer declares setuptools as a dependency as it can be assumed. v40.6.2 ======= Changes ------- * #1592: Fix invalid dependency on external six module (instead of vendored version). v40.6.1 ======= Changes ------- * #1590: Fixed regression where packages without ``author`` or ``author_email`` fields generated malformed package metadata. v40.6.0 ======= Deprecations ------------ * #1541: Officially deprecated the ``requires`` parameter in ``setup()``. Changes ------- * #1519: In ``pkg_resources.normalize_path``, additional path normalization is now performed to ensure path values to a directory is always the same, preventing false positives when checking scripts have a consistent prefix to set up on Windows. * #1545: Changed the warning class of all deprecation warnings; deprecation warning classes are no longer derived from ``DeprecationWarning`` and are thus visible by default. * #1554: ``build_meta.build_sdist`` now includes ``setup.py`` in source distributions by default. * #1576: Started monkey-patching ``get_metadata_version`` and ``read_pkg_file`` onto ``distutils.DistributionMetadata`` to retain the correct version on the ``PKG-INFO`` file in the (deprecated) ``upload`` command. Documentation changes --------------------- * #1395: Changed Pyrex references to Cython in the documentation. * #1456: Documented that the ``rpmbuild`` packages is required for the ``bdist_rpm`` command. * #1537: Documented how to use ``setup.cfg`` for ``src/ layouts`` * #1539: Added minimum version column in ``setup.cfg`` metadata table. * #1552: Fixed a minor typo in the python 2/3 compatibility documentation. * #1553: Updated installation instructions to point to ``pip install`` instead of ``ez_setup.py``. * #1560: Updated ``setuptools`` distribution documentation to remove some outdated information. * #1564: Documented ``setup.cfg`` minimum version for version and project_urls. Misc ---- * #1533: Restricted the ``recursive-include setuptools/_vendor`` to contain only .py and .txt files. * #1572: Added the ``concurrent.futures`` backport ``futures`` to the Python 2.7 test suite requirements. v40.5.0 ======= Changes ------- * #1335: In ``pkg_resources.normalize_path``, fix issue on Cygwin when cwd contains symlinks. * #1502: Deprecated support for downloads from Subversion in package_index/easy_install. * #1517: Dropped use of six.u in favor of ``u""`` literals. * #1520: Added support for ``data_files`` in ``setup.cfg``. Documentation changes --------------------- * #1525: Fixed rendering of the deprecation warning in easy_install doc. v40.4.3 ======= Changes ------- * #1480: Bump vendored pyparsing in pkg_resources to 2.2.1. v40.4.2 ======= Misc ---- * #1497: Updated gitignore in repo. v40.4.1 ======= Changes ------- * #1480: Bump vendored pyparsing to 2.2.1. v40.4.0 ======= Changes ------- * #1481: Join the sdist ``--dist-dir`` and the ``build_meta`` sdist directory argument to point to the same target (meaning the build frontend no longer needs to clean manually the dist dir to avoid multiple sdist presence, and setuptools no longer needs to handle conflicts between the two). v40.3.0 ======= Changes ------- * #1402: Fixed a bug with namespace packages under Python 3.6 when one package in current directory hides another which is installed. * #1427: Set timestamp of ``.egg-info`` directory whenever ``egg_info`` command is run. * #1474: ``build_meta.get_requires_for_build_sdist`` now does not include the ``wheel`` package anymore. * #1486: Suppress warnings in pkg_resources.handle_ns. Misc ---- * #1479: Remove internal use of six.binary_type. v40.2.0 ======= Changes ------- * #1466: Fix handling of Unicode arguments in PEP 517 backend v40.1.1 ======== Changes ------- * #1465: Fix regression with ``egg_info`` command when tagging is used. v40.1.0 ======= Changes ------- * #1410: Deprecated ``upload`` and ``register`` commands. * #1312: Introduced find_namespace_packages() to find PEP 420 namespace packages. * #1420: Added find_namespace: directive to config parser. * #1418: Solved race in when creating egg cache directories. * #1450: Upgraded vendored PyParsing from 2.1.10 to 2.2.0. * #1451: Upgraded vendored appdirs from 1.4.0 to 1.4.3. * #1388: Fixed "Microsoft Visual C++ Build Tools" link in exception when Visual C++ not found. * #1389: Added support for scripts which have unicode content. * #1416: Moved several Python version checks over to using ``six.PY2`` and ``six.PY3``. Misc ---- * #1441: Removed spurious executable permissions from files that don't need them. v40.0.0 ======= Breaking Changes ---------------- * #1342: Drop support for Python 3.3. Changes ------- * #1366: In package_index, fixed handling of encoded entities in URLs. * #1383: In pkg_resources VendorImporter, avoid removing packages imported from the root. Documentation changes --------------------- * #1379: Minor doc fixes after actually using the new release process. * #1385: Removed section on non-package data files. * #1403: Fix developer's guide. Misc ---- * #1404: Fix PEP 518 configuration: set build requirements in ``pyproject.toml`` to ``["wheel"]``. v39.2.0 ======= Changes ------- * #1359: Support using "file:" to load a PEP 440-compliant package version from a text file. * #1360: Fixed issue with a mismatch between the name of the package and the name of the .dist-info file in wheel files * #1364: Add ``__dir__()`` implementation to ``pkg_resources.Distribution()`` that includes the attributes in the ``_provider`` instance variable. * #1365: Take the package_dir option into account when loading the version from a module attribute. Documentation changes --------------------- * #1353: Added coverage badge to README. * #1356: Made small fixes to the developer guide documentation. * #1357: Fixed warnings in documentation builds and started enforcing that the docs build without warnings in tox. * #1376: Updated release process docs. Misc ---- * #1343: The ``setuptools`` specific ``long_description_content_type``, ``project_urls`` and ``provides_extras`` fields are now set consistently after any ``distutils`` ``setup_keywords`` calls, allowing them to override values. * #1352: Added ``tox`` environment for documentation builds. * #1354: Added ``towncrier`` for changelog management. * #1355: Add PR template. * #1368: Fixed tests which failed without network connectivity. * #1369: Added unit tests for PEP 425 compatibility tags support. * #1372: Stop testing Python 3.3 in Travis CI, now that the latest version of ``wheel`` no longer installs on it. v39.1.0 ======= * #1340: Update all PyPI URLs to reflect the switch to the new Warehouse codebase. * #1337: In ``pkg_resources``, now support loading resources for modules loaded by the ``SourcelessFileLoader``. * #1332: Silence spurious wheel related warnings on Windows. v39.0.1 ======= * #1297: Restore Unicode handling for Maintainer fields in metadata. v39.0.0 ======= * #1296: Setuptools now vendors its own direct dependencies, no longer relying on the dependencies as vendored by pkg_resources. * #296: Removed long-deprecated support for iteration on Version objects as returned by ``pkg_resources.parse_version``. Removed the ``SetuptoolsVersion`` and ``SetuptoolsLegacyVersion`` names as well. They should not have been used, but if they were, replace with ``Version`` and ``LegacyVersion`` from ``packaging.version``. v38.7.0 ======= * #1288: Add support for maintainer in PKG-INFO. v38.6.1 ======= * #1292: Avoid generating ``Provides-Extra`` in metadata when no extra is present (but environment markers are). v38.6.0 ======= * #1286: Add support for Metadata 2.1 (PEP 566). v38.5.2 ======= * #1285: Fixed RuntimeError in pkg_resources.parse_requirements on Python 3.7 (stemming from PEP 479). v38.5.1 ======= * #1271: Revert to Cython legacy ``build_ext`` behavior for compatibility. v38.5.0 ======= * #1229: Expand imports in ``build_ext`` to refine detection of Cython availability. * #1270: When Cython is available, ``build_ext`` now uses the new_build_ext. v38.4.1 ======= * #1257: In bdist_egg.scan_module, fix ValueError on Python 3.7. v38.4.0 ======= * #1231: Removed warning when PYTHONDONTWRITEBYTECODE is enabled. v38.3.0 ======= * #1210: Add support for PEP 345 Project-URL metadata. * #1207: Add support for ``long_description_type`` to setup.cfg declarative config as intended and documented. v38.2.5 ======= * #1232: Fix trailing slash handling in ``pkg_resources.ZipProvider``. v38.2.4 ======= * #1220: Fix ``data_files`` handling when installing from wheel. v38.2.3 ======= * fix Travis' Python 3.3 job. v38.2.2 ======= * #1214: fix handling of namespace packages when installing from a wheel. v38.2.1 ======= * #1212: fix encoding handling of metadata when installing from a wheel. v38.2.0 ======= * #1200: easy_install now support installing from wheels: they will be installed as standalone unzipped eggs. v38.1.0 ======= * #1208: Improve error message when failing to locate scripts in egg-info metadata. v38.0.0 ======= * #458: In order to support deterministic builds, Setuptools no longer allows packages to declare ``install_requires`` as unordered sequences (sets or dicts). v37.0.0 ======= * #878: Drop support for Python 2.6. Python 2.6 users should rely on 'setuptools < 37dev'. v36.8.0 ======= * #1190: In SSL support for package index operations, use SNI where available. v36.7.3 ======= * #1175: Bug fixes to ``build_meta`` module. v36.7.2 ======= * #701: Fixed duplicate test discovery on Python 3. v36.7.1 ======= * #1193: Avoid test failures in bdist_egg when PYTHONDONTWRITEBYTECODE is set. v36.7.0 ======= * #1054: Support ``setup_requires`` in ``setup.cfg`` files. v36.6.1 ======= * #1132: Removed redundant and costly serialization/parsing step in ``EntryPoint.__init__``. * #844: ``bdist_egg --exclude-source-files`` now tested and works on Python 3. v36.6.0 ======= * #1143: Added ``setuptools.build_meta`` module, an implementation of PEP-517 for Setuptools-defined packages. * #1143: Added ``dist_info`` command for producing dist_info metadata. v36.5.0 ======= * #170: When working with Mercurial checkouts, use Windows-friendly syntax for suppressing output. * Inspired by #1134, performed substantial refactoring of ``pkg_resources.find_on_path`` to facilitate an optimization for paths with many non-version entries. v36.4.0 ======= * #1075: Add new ``Description-Content-Type`` metadata field. `See here for documentation on how to use this field. `_ * #1068: Sort files and directories when building eggs for deterministic order. * #196: Remove caching of easy_install command in fetch_build_egg. Fixes issue where ``pytest-runner-N.N`` would satisfy the installation of ``pytest``. * #1129: Fix working set dependencies handling when replacing conflicting distributions (e.g. when using ``setup_requires`` with a conflicting transitive dependency, fix #1124). * #1133: Improved handling of README files extensions and added Markdown to the list of searched READMES. * #1135: Improve performance of pkg_resources import by not invoking ``access`` or ``stat`` and using ``os.listdir`` instead. v36.3.0 ======= * #1131: Make possible using several files within ``file:`` directive in metadata.long_description in ``setup.cfg``. v36.2.7 ======= * fix #1105: Fix handling of requirements with environment markers when declared in ``setup.cfg`` (same treatment as for #1081). v36.2.6 ======= * #462: Don't assume a directory is an egg by the ``.egg`` extension alone. v36.2.5 ======= * #1093: Fix test command handler with extras_require. * #1112, #1091, #1115: Now using Trusty containers in Travis for CI and CD. v36.2.4 ======= * #1092: ``pkg_resources`` now uses ``inspect.getmro`` to resolve classes in method resolution order. v36.2.3 ======= * #1102: Restore behavior for empty extras. v36.2.2 ======= * #1099: Revert commit a3ec721, restoring intended purpose of extras as part of a requirement declaration. v36.2.1 ======= * fix #1086 * fix #1087 * support extras specifiers in install_requires requirements v36.2.0 ======= * #1081: Environment markers indicated in ``install_requires`` are now processed and treated as nameless ``extras_require`` with markers, allowing their metadata in requires.txt to be correctly generated. * #1053: Tagged commits are now released using Travis-CI build stages, meaning releases depend on passing tests on all supported Python versions (Linux) and not just the latest Python version. v36.1.1 ======= * #1083: Correct ``py31compat.makedirs`` to correctly honor ``exist_ok`` parameter. * #1083: Also use makedirs compatibility throughout setuptools. v36.1.0 ======= * #1083: Avoid race condition on directory creation in ``pkg_resources.ensure_directory``. * Removed deprecation of and restored support for ``upload_docs`` command for sites other than PyPI. Only warehouse is dropping support, but services like `devpi `_ continue to support docs built by setuptools' plugins. See `this comment `_ for more context on the motivation for this change. v36.0.1 ======= * #1042: Fix import in py27compat module that still referenced six directly, rather than through the externs module (vendored packages hook). v36.0.0 ======= * #980 and others: Once again, Setuptools vendors all of its dependencies. It seems to be the case that in the Python ecosystem, all build tools must run without any dependencies (build, runtime, or otherwise). At such a point that a mechanism exists that allows build tools to have dependencies, Setuptools will adopt it. v35.0.2 ======= * #1015: Fix test failures on Python 3.7. * #1024: Add workaround for Jython #2581 in monkey module. v35.0.1 ======= * #992: Revert change introduced in v34.4.1, now considered invalid. * #1016: Revert change introduced in v35.0.0 per #1014, referencing #436. The approach had unintended consequences, causing sdist installs to be missing files. v35.0.0 ======= * #436: In egg_info.manifest_maker, no longer read the file list from the manifest file, and instead re-build it on each build. In this way, files removed from the specification will not linger in the manifest. As a result, any files manually added to the manifest will be removed on subsequent egg_info invocations. No projects should be manually adding files to the manifest and should instead use MANIFEST.in or SCM file finders to force inclusion of files in the manifest. v34.4.1 ======= * #1008: In MSVC support, use always the last version available for Windows SDK and UCRT SDK. * #1008: In MSVC support, fix "vcruntime140.dll" returned path with Visual Studio 2017. * #992: In msvc.msvc9_query_vcvarsall, ensure the returned dicts have str values and not Unicode for compatibility with os.environ. v34.4.0 ======= * #995: In MSVC support, add support for "Microsoft Visual Studio 2017" and "Microsoft Visual Studio Build Tools 2017". * #999 via #1007: Extend support for declarative package config in a setup.cfg file to include the options ``python_requires`` and ``py_modules``. v34.3.3 ======= * #967 (and #997): Explicitly import submodules of packaging to account for environments where the imports of those submodules is not implied by other behavior. v34.3.2 ======= * #993: Fix documentation upload by correcting rendering of content-type in _build_multipart on Python 3. v34.3.1 ======= * #988: Trap ``os.unlink`` same as ``os.remove`` in ``auto_chmod`` error handler. * #983: Fixes to invalid escape sequence deprecations on Python 3.6. v34.3.0 ======= * #941: In the upload command, if the username is blank, default to ``getpass.getuser()``. * #971: Correct distutils findall monkeypatch to match appropriate versions (namely Python 3.4.6). v34.2.0 ======= * #966: Add support for reading dist-info metadata and thus locating Distributions from zip files. * #968: Allow '+' and '!' in egg fragments so that it can take package names that contain PEP 440 conforming version specifiers. v34.1.1 ======= * #953: More aggressively employ the compatibility issue originally added in #706. v34.1.0 ======= * #930: ``build_info`` now accepts two new parameters to optimize and customize the building of C libraries. v34.0.3 ======= * #947: Loosen restriction on the version of six required, restoring compatibility with environments relying on six 1.6.0 and later. v34.0.2 ======= * #882: Ensure extras are honored when building the working set. * #913: Fix issue in develop if package directory has a trailing slash. v34.0.1 ======= * #935: Fix glob syntax in graft. v34.0.0 ======= * #581: Instead of vendoring the growing list of dependencies that Setuptools requires to function, Setuptools now requires these dependencies just like any other project. Unlike other projects, however, Setuptools cannot rely on ``setup_requires`` to demand the dependencies it needs to install because its own machinery would be necessary to pull those dependencies if not present (a bootstrapping problem). As a result, Setuptools no longer supports self upgrade or installation in the general case. Instead, users are directed to use pip to install and upgrade using the ``wheel`` distributions of setuptools. Users are welcome to contrive other means to install or upgrade Setuptools using other means, such as pre-installing the Setuptools dependencies with pip or a bespoke bootstrap tool, but such usage is not recommended and is not supported. As discovered in #940, not all versions of pip will successfully install Setuptools from its pre-built wheel. If you encounter issues with "No module named six" or "No module named packaging", especially following a line "Running setup.py egg_info for package setuptools", then your pip is not new enough. There's an additional issue in pip where setuptools is upgraded concurrently with other source packages, described in pip #4253. The proposed workaround is to always upgrade Setuptools first prior to upgrading other packages that would upgrade Setuptools. v33.1.1 ======= * #921: Correct issue where certifi fallback not being reached on Windows. v33.1.0 ======= Installation via pip, as indicated in the `Python Packaging User's Guide `_, is the officially-supported mechanism for installing Setuptools, and this recommendation is now explicit in the much more concise README. Other edits and tweaks were made to the documentation. The codebase is unchanged. v33.0.0 ======= * #619: Removed support for the ``tag_svn_revision`` distribution option. If Subversion tagging support is still desired, consider adding the functionality to setuptools_svn in setuptools_svn #2. v32.3.1 ======= * #866: Use ``dis.Bytecode`` on Python 3.4 and later in ``setuptools.depends``. v32.3.0 ======= * #889: Backport proposed fix for disabling interpolation in distutils.Distribution.parse_config_files. v32.2.0 ======= * #884: Restore support for running the tests under `pytest-runner `_ by ensuring that PYTHONPATH is honored in tests invoking a subprocess. v32.1.3 ======= * #706: Add rmtree compatibility shim for environments where rmtree fails when passed a unicode string. v32.1.2 ======= * #893: Only release sdist in zip format as warehouse now disallows releasing two different formats. v32.1.1 ======= * #704: More selectively ensure that 'rmtree' is not invoked with a byte string, enabling it to remove files that are non-ascii, even on Python 2. * #712: In 'sandbox.run_setup', ensure that ``__file__`` is always a ``str``, modeling the behavior observed by the interpreter when invoking scripts and modules. v32.1.0 ======= * #891: In 'test' command on test failure, raise DistutilsError, suppression invocation of subsequent commands. v32.0.0 ======= * #890: Revert #849. ``global-exclude .foo`` will not match all ``*.foo`` files any more. Package authors must add an explicit wildcard, such as ``global-exclude *.foo``, to match all ``.foo`` files. See #886, #849. v31.0.1 ======= * #885: Fix regression where 'pkg_resources._rebuild_mod_path' would fail when a namespace package's '__path__' was not a list with a sort attribute. v31.0.0 ======= * #250: Install '-nspkg.pth' files for packages installed with 'setup.py develop'. These .pth files allow namespace packages installed by pip or develop to co-mingle. This change required the removal of the change for #805 and pip #1924, introduced in 28.3.0 and implicated in #870, but means that namespace packages not in a site packages directory will no longer work on Python earlier than 3.5, whereas before they would work on Python not earlier than 3.3. v30.4.0 ======= * #879: For declarative config: - read_configuration() now accepts ignore_option_errors argument. This allows scraping tools to read metadata without a need to download entire packages. E.g. we can gather some stats right from GitHub repos just by downloading setup.cfg. - packages find: directive now supports fine tuning from a subsection. The same arguments as for find() are accepted. v30.3.0 ======= * #394 via #862: Added support for `declarative package config in a setup.cfg file `_. v30.2.1 ======= * #850: In test command, invoke unittest.main with indication not to exit the process. v30.2.0 ======= * #854: Bump to vendored Packaging 16.8. v30.1.0 ======= * #846: Also trap 'socket.error' when opening URLs in package_index. * #849: Manifest processing now matches the filename pattern anywhere in the filename and not just at the start. Restores behavior found prior to 28.5.0. v30.0.0 ======= * #864: Drop support for Python 3.2. Systems requiring Python 3.2 support must use 'setuptools < 30'. * #825: Suppress warnings for single files. * #830 via #843: Once again restored inclusion of data files to sdists, but now trap TypeError caused by techniques employed rjsmin and similar. v29.0.1 ======= * #861: Re-release of v29.0.1 with the executable script launchers bundled. Now, launchers are included by default and users that want to disable this behavior must set the environment variable 'SETUPTOOLS_INSTALL_WINDOWS_SPECIFIC_FILES' to a false value like "false" or "0". v29.0.0 ======= * #841: Drop special exception for packages invoking win32com during the build/install process. See Distribute #118 for history. v28.8.0 ======= * #629: Per the discussion, refine the sorting to use version value order for more accurate detection of the latest available version when scanning for packages. See also #829. * #837: Rely on the config var "SO" for Python 3.3.0 only when determining the ext filename. v28.7.1 ======= * #827: Update PyPI root for dependency links. * #833: Backed out changes from #830 as the implementation seems to have problems in some cases. v28.7.0 ======= * #832: Moved much of the namespace package handling functionality into a separate module for re-use in something like #789. * #830: ``sdist`` command no longer suppresses the inclusion of data files, re-aligning with the expectation of distutils and addressing #274 and #521. v28.6.1 ======= * #816: Fix manifest file list order in tests. v28.6.0 ======= * #629: When scanning for packages, ``pkg_resources`` now ignores empty egg-info directories and gives precedence to packages whose versions are lexicographically greatest, a rough approximation for preferring the latest available version. v28.5.0 ======= * #810: Tests are now invoked with tox and not setup.py test. * #249 and #450 via #764: Avoid scanning the whole tree when building the manifest. Also fixes a long-standing bug where patterns in ``MANIFEST.in`` had implicit wildcard matching. This caused ``global-exclude .foo`` to exclude all ``*.foo`` files, but also ``global-exclude bar.py`` to exclude ``foo_bar.py``. v28.4.0 ======= * #732: Now extras with a hyphen are honored per PEP 426. * #811: Update to pyparsing 2.1.10. * Updated ``setuptools.command.sdist`` to re-use most of the functionality directly from ``distutils.command.sdist`` for the ``add_defaults`` method with strategic overrides. See #750 for rationale. * #760 via #762: Look for certificate bundle where SUSE Linux typically presents it. Use ``certifi.where()`` to locate the bundle. v28.3.0 ======= * #809: In ``find_packages()``, restore support for excluding a parent package without excluding a child package. * #805: Disable ``-nspkg.pth`` behavior on Python 3.3+ where PEP-420 functionality is adequate. Fixes pip #1924. v28.1.0 ======= * #803: Bump certifi to 2016.9.26. v28.0.0 ======= * #733: Do not search excluded directories for packages. This introduced a backwards incompatible change in ``find_packages()`` so that ``find_packages(exclude=['foo']) == []``, excluding subpackages of ``foo``. Previously, ``find_packages(exclude=['foo']) == ['foo.bar']``, even though the parent ``foo`` package was excluded. * #795: Bump certifi. * #719: Suppress decoding errors and instead log a warning when metadata cannot be decoded. v27.3.1 ======= * #790: In MSVC monkeypatching, explicitly patch each function by name in the target module instead of inferring the module from the function's ``__module__``. Improves compatibility with other packages that might have previously patched distutils functions (i.e. NumPy). v27.3.0 ======= * #794: In test command, add installed eggs to PYTHONPATH when invoking tests so that subprocesses will also have the dependencies available. Fixes `tox 330 `_. * #795: Update vendored pyparsing 2.1.9. v27.2.0 ======= * #520 and #513: Suppress ValueErrors in fixup_namespace_packages when lookup fails. * Nicer, more consistent interfaces for msvc monkeypatching. v27.1.2 ======= * #779 via #781: Fix circular import. v27.1.1 ======= * #778: Fix MSVC monkeypatching. v27.1.0 ======= * Introduce the (private) ``monkey`` module to encapsulate the distutils monkeypatching behavior. v27.0.0 ======= * Now use Warehouse by default for ``upload``, patching ``distutils.config.PyPIRCCommand`` to affect default behavior. Any config in .pypirc should be updated to replace https://pypi.python.org/pypi/ with https://upload.pypi.org/legacy/ Similarly, any passwords stored in the keyring should be updated to use this new value for "system". The ``upload_docs`` command will continue to use the python.org site, but the command is now deprecated. Users are urged to use Read The Docs instead. * #776: Use EXT_SUFFIX for py_limited_api renaming. * #774 and #775: Use LegacyVersion from packaging when detecting numpy versions. v26.1.1 ======= * Re-release of 26.1.0 with pytest pinned to allow for automated deployment and thus proper packaging environment variables, fixing issues with missing executable launchers. v26.1.0 ======= * #763: ``pkg_resources.get_default_cache`` now defers to the :pypi:`appdirs` project to resolve the cache directory. Adds a vendored dependency on appdirs to pkg_resources. v26.0.0 ======= * #748: By default, sdists are now produced in gzipped tarfile format by default on all platforms, adding forward compatibility for the same behavior in Python 3.6 (See Python #27819). * #459 via #736: On Windows with script launchers, sys.argv[0] now reflects the name of the entry point, consistent with the behavior in distlib and pip wrappers. * #752 via #753: When indicating ``py_limited_api`` to Extension, it must be passed as a keyword argument. v25.4.0 ======= * Add Extension(py_limited_api=True). When set to a truthy value, that extension gets a filename appropriate for code using Py_LIMITED_API. When used correctly this allows a single compiled extension to work on all future versions of CPython 3. The py_limited_api argument only controls the filename. To be compatible with multiple versions of Python 3, the C extension will also need to set -DPy_LIMITED_API=... and be modified to use only the functions in the limited API. v25.3.0 ======= * #739 Fix unquoted libpaths by fixing compatibility between ``numpy.distutils`` and ``distutils._msvccompiler`` for numpy < 1.11.2 (Fix issue #728, error also fixed in Numpy). * #731: Bump certifi. * Style updates. See #740, #741, #743, #744, #742, #747. * #735: include license file. v25.2.0 ======= * #612 via #730: Add a LICENSE file which needs to be provided by the terms of the MIT license. v25.1.6 ======= * #725: revert ``library_dir_option`` patch (Error is related to ``numpy.distutils`` and make errors on non Numpy users). v25.1.5 ======= * #720 * #723: Improve patch for ``library_dir_option``. v25.1.4 ======= * #717 * #713 * #707: Fix Python 2 compatibility for MSVC by catching errors properly. * #715: Fix unquoted libpaths by patching ``library_dir_option``. v25.1.3 ======= * #714 and #704: Revert fix as it breaks other components downstream that can't handle unicode. See #709, #710, and #712. v25.1.2 ======= * #704: Fix errors when installing a zip sdist that contained files named with non-ascii characters on Windows would crash the install when it attempted to clean up the build. * #646: MSVC compatibility - catch errors properly in RegistryInfo.lookup. * #702: Prevent UnboundLocalError when initial working_set is empty. v25.1.1 ======= * #686: Fix issue in sys.path ordering by pkg_resources when rewrite technique is "raw". * #699: Fix typo in msvc support. v25.1.0 ======= * #609: Setuptools will now try to download a distribution from the next possible download location if the first download fails. This means you can now specify multiple links as ``dependency_links`` and all links will be tried until a working download link is encountered. v25.0.2 ======= * #688: Fix AttributeError in setup.py when invoked not from the current directory. v25.0.1 ======= * Cleanup of setup.py script. * Fixed documentation builders by allowing setup.py to be imported without having bootstrapped the metadata. * More style cleanup. See #677, #678, #679, #681, #685. v25.0.0 ======= * #674: Default ``sys.path`` manipulation by easy-install.pth is now "raw", meaning that when writing easy-install.pth during any install operation, the ``sys.path`` will not be rewritten and will no longer give preference to easy_installed packages. To retain the old behavior when using any easy_install operation (including ``setup.py install`` when setuptools is present), set the environment variable: SETUPTOOLS_SYS_PATH_TECHNIQUE=rewrite This project hopes that that few if any environments find it necessary to retain the old behavior, and intends to drop support for it altogether in a future release. Please report any relevant concerns in the ticket for this change. v24.3.1 ======= * #398: Fix shebang handling on Windows in script headers where spaces in ``sys.executable`` would produce an improperly-formatted shebang header, introduced in 12.0 with the fix for #188. * #663, #670: More style updates. v24.3.0 ======= * #516: Disable ``os.link`` to avoid hard linking in ``sdist.make_distribution``, avoiding errors on systems that support hard links but not on the file system in which the build is occurring. v24.2.1 ======= * #667: Update Metadata-Version to 1.2 when ``python_requires`` is supplied. v24.2.0 ======= * #631: Add support for ``python_requires`` keyword. v24.1.1 ======= * More style updates. See #660, #661, #641. v24.1.0 ======= * #659: ``setup.py`` now will fail fast and with a helpful error message when the necessary metadata is missing. * More style updates. See #656, #635, #640, #644, #650, #652, and #655. v24.0.3 ======= * Updated style in much of the codebase to match community expectations. See #632, #633, #634, #637, #639, #638, #642, #648. v24.0.2 ======= * If MSVC++14 is needed ``setuptools.msvc`` now redirect user to Visual C++ Build Tools web page. v24.0.1 ======= * #625 and #626: Fixes on ``setuptools.msvc`` mainly for Python 2 and Linux. v24.0.0 ======= * Pull Request #174: Add more aggressive support for standalone Microsoft Visual C++ compilers in msvc9compiler patch. Particularly : Windows SDK 6.1 and 7.0 (MSVC++ 9.0), Windows SDK 7.1 (MSVC++ 10.0), Visual C++ Build Tools 2015 (MSVC++14) * Renamed ``setuptools.msvc9_support`` to ``setuptools.msvc``. v23.2.1 ======= Re-release of v23.2.0, which was missing the intended commits. * #623: Remove used of deprecated 'U' flag when reading manifests. v23.1.0 ======= * #619: Deprecated ``tag_svn_revision`` distribution option. v23.0.0 ======= * #611: Removed ARM executables for CLI and GUI script launchers on Windows. If this was a feature you cared about, please comment in the ticket. * #604: Removed docs building support. The project now relies on documentation hosted at https://setuptools.pypa.io/. v22.0.5 ======= * #604: Restore repository for upload_docs command to restore publishing of docs during release. v22.0.4 ======= * #589: Upload releases to pypi.io using the upload hostname and legacy path. v22.0.3 ======= * #589: Releases are now uploaded to pypi.io (Warehouse) even when releases are made on Twine via Travis. v22.0.2 ======= * #589: Releases are now uploaded to pypi.io (Warehouse). v22.0.1 ======= * #190: On Python 2, if unicode is passed for packages to ``build_py`` command, it will be handled just as with text on Python 3. v22.0.0 ======= Intended to be v21.3.0, but jaraco accidentally released as a major bump. * #598: Setuptools now lists itself first in the User-Agent for web requests, better following the guidelines in `RFC 7231 `_. v21.2.2 ======= * Minor fixes to changelog and docs. v21.2.1 ======= * #261: Exclude directories when resolving globs in package_data. v21.2.0 ======= * #539: In the easy_install get_site_dirs, honor all paths found in ``site.getsitepackages``. v21.1.0 ======= * #572: In build_ext, now always import ``_CONFIG_VARS`` from ``distutils`` rather than from ``sysconfig`` to allow ``distutils.sysconfig.customize_compiler`` configure the OS X compiler for ``-dynamiclib``. v21.0.0 ======= * Removed ez_setup.py from Setuptools sdist. The bootstrap script will be maintained in its own branch and should be generally be retrieved from its canonical location at https://bootstrap.pypa.io/ez_setup.py. v20.10.0 ======== * #553: egg_info section is now generated in a deterministic order, matching the order generated by earlier versions of Python. Except on Python 2.6, order is preserved when existing settings are present. * #556: Update to Packaging 16.7, restoring support for deprecated ``python_implmentation`` marker. * #555: Upload command now prompts for a password when uploading to PyPI (or other repository) if no password is present in .pypirc or in the keyring. v20.9.0 ======= * #548: Update certify version to 2016.2.28 * #545: Safely handle deletion of non-zip eggs in rotate command. v20.8.1 ======= * Issue #544: Fix issue with extra environment marker processing in WorkingSet due to refactor in v20.7.0. v20.8.0 ======= * Issue #543: Re-release so that latest release doesn't cause déjà vu with distribute and setuptools 0.7 in older environments. v20.7.0 ======= * Refactored extra environment marker processing in WorkingSet. * Issue #533: Fixed intermittent test failures. * Issue #536: In msvc9_support, trap additional exceptions that might occur when importing ``distutils.msvc9compiler`` in mingw environments. * Issue #537: Provide better context when package metadata fails to decode in UTF-8. v20.6.8 ======= * Issue #523: Restored support for environment markers, now honoring 'extra' environment markers. v20.6.7 ======= * Issue #523: Disabled support for environment markers introduced in v20.5. v20.6.6 ======= * Issue #503: Restore support for PEP 345 environment markers by updating to Packaging 16.6. v20.6.0 ======= * New release process that relies on `bumpversion `_ and Travis CI for continuous deployment. * Project versioning semantics now follow `semver `_ precisely. The 'v' prefix on version numbers now also allows version numbers to be referenced in the changelog, e.g. http://setuptools.pypa.io/en/latest/history.html#v20-6-0. 20.5 ==== * BB Pull Request #185, #470: Add support for environment markers in requirements in install_requires, setup_requires, tests_require as well as adding a test for the existing extra_requires machinery. 20.4 ==== * Issue #422: Moved hosting to `Github `_ from `Bitbucket `_. Issues have been migrated, though all issues and comments are attributed to bb-migration. So if you have a particular issue or issues to which you've been subscribed, you will want to "watch" the equivalent issue in Github. The Bitbucket project will be retained for the indefinite future, but Github now hosts the canonical project repository. 20.3.1 ====== * Issue #519: Remove import hook when reloading the ``pkg_resources`` module. * BB Pull Request #184: Update documentation in ``pkg_resources`` around new ``Requirement`` implementation. 20.3 ==== * BB Pull Request #179: ``pkg_resources.Requirement`` objects are now a subclass of ``packaging.requirements.Requirement``, allowing any environment markers and url (if any) to be affiliated with the requirement * BB Pull Request #179: Restore use of RequirementParseError exception unintentionally dropped in 20.2. 20.2.2 ====== * Issue #502: Correct regression in parsing of multiple version specifiers separated by commas and spaces. 20.2.1 ====== * Issue #499: Restore compatibility for legacy versions by bumping to packaging 16.4. 20.2 ==== * Changelog now includes release dates and links to PEPs. * BB Pull Request #173: Replace dual PEP 345 _markerlib implementation and PEP 426 implementation of environment marker support from packaging 16.1 and PEP 508. Fixes Issue #122. See also BB Pull Request #175, BB Pull Request #168, and BB Pull Request #164. Additionally: - ``Requirement.parse`` no longer retains the order of extras. - ``parse_requirements`` now requires that all versions be PEP-440 compliant, as revealed in #499. Packages released with invalid local versions should be re-released using the proper local version syntax, e.g. ``mypkg-1.0+myorg.1``. 20.1.1 ====== * Update ``upload_docs`` command to also honor keyring for password resolution. 20.1 ==== * Added support for using passwords from keyring in the upload command. See `the upload docs `_ for details. 20.0 ==== * Issue #118: Once again omit the package metadata (egg-info) from the list of outputs in ``--record``. This version of setuptools can no longer be used to upgrade pip earlier than 6.0. 19.7 ==== * Off-project PR: `0dcee79 `_ and `f9bd9b9 `_ For FreeBSD, also `honor root certificates from ca_root_nss `_. 19.6.2 ====== * Issue #491: Correct regression incurred in 19.4 where a double-namespace package installed using pip would cause a TypeError. 19.6.1 ====== * Restore compatibility for PyPy 3 compatibility lost in 19.4.1 addressing Issue #487. * ``setuptools.launch`` shim now loads scripts in a new namespace, avoiding getting relative imports from the setuptools package on Python 2. 19.6 ==== * Added a new entry script ``setuptools.launch``, implementing the shim found in ``pip.util.setuptools_build``. Use this command to launch distutils-only packages under setuptools in the same way that pip does, causing the setuptools monkeypatching of distutils to be invoked prior to invoking a script. Useful for debugging or otherwise installing a distutils-only package under setuptools when pip isn't available or otherwise does not expose the desired functionality. For example:: $ python -m setuptools.launch setup.py develop * Issue #488: Fix dual manifestation of Extension class in extension packages installed as dependencies when Cython is present. 19.5 ==== * Issue #486: Correct TypeError when getfilesystemencoding returns None. * Issue #139: Clarified the license as MIT. * BB Pull Request #169: Removed special handling of command spec in scripts for Jython. 19.4.1 ====== * Issue #487: Use direct invocation of ``importlib.machinery`` in ``pkg_resources`` to avoid missing detection on relevant platforms. 19.4 ==== * Issue #341: Correct error in path handling of package data files in ``build_py`` command when package is empty. * Distribute #323, Issue #141, Issue #207, and BB Pull Request #167: Another implementation of ``pkg_resources.WorkingSet`` and ``pkg_resources.Distribution`` that supports replacing an extant package with a new one, allowing for setup_requires dependencies to supersede installed packages for the session. 19.3 ==== * Issue #229: Implement new technique for readily incorporating dependencies conditionally from vendored copies or primary locations. Adds a new dependency on six. 19.2 ==== * BB Pull Request #163: Add get_command_list method to Distribution. * BB Pull Request #162: Add missing whitespace to multiline string literals. 19.1.1 ====== * Issue #476: Cast version to string (using default encoding) to avoid creating Unicode types on Python 2 clients. * Issue #477: In Powershell downloader, use explicit rendering of strings, rather than rely on ``repr``, which can be incorrect (especially on Python 2). 19.1 ==== * Issue #215: The bootstrap script ``ez_setup.py`` now automatically detects the latest version of setuptools (using PyPI JSON API) rather than hard-coding a particular value. * Issue #475: Fix incorrect usage in _translate_metadata2. 19.0 ==== * Issue #442: Use RawConfigParser for parsing .pypirc file. Interpolated values are no longer honored in .pypirc files. 18.8.1 ====== * Issue #440: Prevent infinite recursion when a SandboxViolation or other UnpickleableException occurs in a sandbox context with setuptools hidden. Fixes regression introduced in Setuptools 12.0. 18.8 ==== * Deprecated ``egg_info.get_pkg_info_revision``. * Issue #471: Don't rely on repr for an HTML attribute value in package_index. * Issue #419: Avoid errors in FileMetadata when the metadata directory is broken. * Issue #472: Remove deprecated use of 'U' in mode parameter when opening files. 18.7.1 ====== * Issue #469: Refactored logic for Issue #419 fix to re-use metadata loading from Provider. 18.7 ==== * Update dependency on certify. * BB Pull Request #160: Improve detection of gui script in ``easy_install._adjust_header``. * Made ``test.test_args`` a non-data property; alternate fix for the issue reported in BB Pull Request #155. * Issue #453: In ``ez_setup`` bootstrap module, unload all ``pkg_resources`` modules following download. * BB Pull Request #158: Honor PEP-488 when excluding files for namespace packages. * Issue #419 and BB Pull Request #144: Add experimental support for reading the version info from distutils-installed metadata rather than using the version in the filename. 18.6.1 ====== * Issue #464: Correct regression in invocation of superclass on old-style class on Python 2. 18.6 ==== * Issue #439: When installing entry_point scripts under development, omit the version number of the package, allowing any version of the package to be used. 18.5 ==== * In preparation for dropping support for Python 3.2, a warning is now logged when pkg_resources is imported on Python 3.2 or earlier Python 3 versions. * `Add support for python_platform_implementation environment marker `_. * `Fix dictionary mutation during iteration `_. 18.4 ==== * Issue #446: Test command now always invokes unittest, even if no test suite is supplied. 18.3.2 ====== * Correct another regression in setuptools.findall where the fix for Python #12885 was lost. 18.3.1 ====== * Issue #425: Correct regression in setuptools.findall. 18.3 ==== * BB Pull Request #135: Setuptools now allows disabling of the manipulation of the sys.path during the processing of the easy-install.pth file. To do so, set the environment variable ``SETUPTOOLS_SYS_PATH_TECHNIQUE`` to anything but "rewrite" (consider "raw"). During any install operation with manipulation disabled, setuptools packages will be appended to sys.path naturally. Future versions may change the default behavior to disable manipulation. If so, the default behavior can be retained by setting the variable to "rewrite". * Issue #257: ``easy_install --version`` now shows more detail about the installation location and Python version. * Refactor setuptools.findall in preparation for re-submission back to distutils. 18.2 ==== * Issue #412: More efficient directory search in ``find_packages``. 18.1 ==== * Upgrade to vendored packaging 15.3. 18.0.1 ====== * Issue #401: Fix failure in test suite. 18.0 ==== * Dropped support for builds with Pyrex. Only Cython is supported. * Issue #288: Detect Cython later in the build process, after ``setup_requires`` dependencies are resolved. Projects backed by Cython can now be readily built with a ``setup_requires`` dependency. For example:: ext = setuptools.Extension('mylib', ['src/CythonStuff.pyx', 'src/CStuff.c']) setuptools.setup( ... ext_modules=[ext], setup_requires=['cython'], ) For compatibility with older versions of setuptools, packagers should still include ``src/CythonMod.c`` in the source distributions or require that Cython be present before building source distributions. However, for systems with this build of setuptools, Cython will be downloaded on demand. * Issue #396: Fixed test failure on OS X. * BB Pull Request #136: Remove excessive quoting from shebang headers for Jython. 17.1.1 ====== * Backed out unintended changes to pkg_resources, restoring removal of deprecated imp module (`ref `_). 17.1 ==== * Issue #380: Add support for range operators on environment marker evaluation. 17.0 ==== * Issue #378: Do not use internal importlib._bootstrap module. * Issue #390: Disallow console scripts with path separators in the name. Removes unintended functionality and brings behavior into parity with pip. 16.0 ==== * BB Pull Request #130: Better error messages for errors in parsed requirements. * BB Pull Request #133: Removed ``setuptools.tests`` from the installed packages. * BB Pull Request #129: Address deprecation warning due to usage of imp module. 15.2 ==== * Issue #373: Provisionally expose ``pkg_resources._initialize_master_working_set``, allowing for imperative re-initialization of the master working set. 15.1 ==== * Updated to Packaging 15.1 to address Packaging #28. * Fix ``setuptools.sandbox._execfile()`` with Python 3.1. 15.0 ==== * BB Pull Request #126: DistributionNotFound message now lists the package or packages that required it. E.g.:: pkg_resources.DistributionNotFound: The 'colorama>=0.3.1' distribution was not found and is required by smlib.log. Note that zc.buildout once dependended on the string rendering of this message to determine the package that was not found. This expectation has since been changed, but older versions of buildout may experience problems. See Buildout #242 for details. 14.3.1 ====== * Issue #307: Removed PEP-440 warning during parsing of versions in ``pkg_resources.Distribution``. * Issue #364: Replace deprecated usage with recommended usage of ``EntryPoint.load``. 14.3 ==== * Issue #254: When creating temporary egg cache on Unix, use mode 755 for creating the directory to avoid the subsequent warning if the directory is group writable. 14.2 ==== * Issue #137: Update ``Distribution.hashcmp`` so that Distributions with None for pyversion or platform can be compared against Distributions defining those attributes. 14.1.1 ====== * Issue #360: Removed undesirable behavior from test runs, preventing write tests and installation to system site packages. 14.1 ==== * BB Pull Request #125: Add ``__ne__`` to Requirement class. * Various refactoring of easy_install. 14.0 ==== * Bootstrap script now accepts ``--to-dir`` to customize save directory or allow for re-use of existing repository of setuptools versions. See BB Pull Request #112 for background. * Issue #285: ``easy_install`` no longer will default to installing packages to the "user site packages" directory if it is itself installed there. Instead, the user must pass ``--user`` in all cases to install packages to the user site packages. This behavior now matches that of "pip install". To configure an environment to always install to the user site packages, consider using the "install-dir" and "scripts-dir" parameters to easy_install through an appropriate distutils config file. 13.0.2 ====== * Issue #359: Include pytest.ini in the sdist so invocation of py.test on the sdist honors the pytest configuration. 13.0.1 ====== Re-release of 13.0. Intermittent connectivity issues caused the release process to fail and PyPI uploads no longer accept files for 13.0. 13.0 ==== * Issue #356: Back out BB Pull Request #119 as it requires Setuptools 10 or later as the source during an upgrade. * Removed build_py class from setup.py. According to 892f439d216e, this functionality was added to support upgrades from old Distribute versions, 0.6.5 and 0.6.6. 12.4 ==== * BB Pull Request #119: Restore writing of ``setup_requires`` to metadata (previously added in 8.4 and removed in 9.0). 12.3 ==== * Documentation is now linked using the rst.linker package. * Fix ``setuptools.command.easy_install.extract_wininst_cfg()`` with Python 2.6 and 2.7. * Issue #354. Added documentation on building setuptools documentation. 12.2 ==== * Issue #345: Unload all modules under pkg_resources during ``ez_setup.use_setuptools()``. * Issue #336: Removed deprecation from ``ez_setup.use_setuptools``, as it is clearly still used by buildout's bootstrap. ``ez_setup`` remains deprecated for use by individual packages. * Simplified implementation of ``ez_setup.use_setuptools``. 12.1 ==== * BB Pull Request #118: Soften warning for non-normalized versions in Distribution. 12.0.5 ====== * Issue #339: Correct Attribute reference in ``cant_write_to_target``. * Issue #336: Deprecated ``ez_setup.use_setuptools``. 12.0.4 ====== * Issue #335: Fix script header generation on Windows. 12.0.3 ====== * Fixed incorrect class attribute in ``install_scripts``. Tests would be nice. 12.0.2 ====== * Issue #331: Fixed ``install_scripts`` command on Windows systems corrupting the header. 12.0.1 ====== * Restore ``setuptools.command.easy_install.sys_executable`` for pbr compatibility. For the future, tools should construct a CommandSpec explicitly. 12.0 ==== * Issue #188: Setuptools now support multiple entities in the value for ``build.executable``, such that an executable of "/usr/bin/env my-python" may be specified. This means that systems with a specified executable whose name has spaces in the path must be updated to escape or quote that value. * Deprecated ``easy_install.ScriptWriter.get_writer``, replaced by ``.best()`` with slightly different semantics (no force_windows flag). 11.3.1 ====== * Issue #327: Formalize and restore support for any printable character in an entry point name. 11.3 ==== * Expose ``EntryPoint.resolve`` in place of EntryPoint._load, implementing the simple, non-requiring load. Deprecated all uses of ``EntryPoint._load`` except for calling with no parameters, which is just a shortcut for ``ep.require(); ep.resolve();``. Apps currently invoking ``ep.load(require=False)`` should instead do the following if wanting to avoid the deprecating warning:: getattr(ep, "resolve", lambda: ep.load(require=False))() 11.2 ==== * Pip #2326: Report deprecation warning at stacklevel 2 for easier diagnosis. 11.1 ==== * Issue #281: Since Setuptools 6.1 (Issue #268), a ValueError would be raised in certain cases where VersionConflict was raised with two arguments, which occurred in ``pkg_resources.WorkingSet.find``. This release adds support for indicating the dependent packages while maintaining support for a VersionConflict when no dependent package context is known. New unit tests now capture the expected interface. 11.0 ==== * Interop #3: Upgrade to Packaging 15.0; updates to PEP 440 so that >1.7 does not exclude 1.7.1 but does exclude 1.7.0 and 1.7.0.post1. 10.2.1 ====== * Issue #323: Fix regression in entry point name parsing. 10.2 ==== * Deprecated use of EntryPoint.load(require=False). Passing a boolean to a function to select behavior is an anti-pattern. Instead use ``Entrypoint._load()``. * Substantial refactoring of all unit tests. Tests are now much leaner and re-use a lot of fixtures and contexts for better clarity of purpose. 10.1 ==== * Issue #320: Added a compatibility implementation of ``sdist._default_revctrl`` so that systems relying on that interface do not fail (namely, Ubuntu 12.04 and similar Debian releases). 10.0.1 ====== * Issue #319: Fixed issue installing pure distutils packages. 10.0 ==== * Issue #313: Removed built-in support for subversion. Projects wishing to retain support for subversion will need to use a third party library. The extant implementation is being ported to :pypi:`setuptools_svn`. * Issue #315: Updated setuptools to hide its own loaded modules during installation of another package. This change will enable setuptools to upgrade (or downgrade) itself even when its own metadata and implementation change. 9.1 === * Prefer vendored packaging library `as recommended `_. 9.0.1 ===== * Issue #312: Restored presence of pkg_resources API tests (doctest) to sdist. 9.0 === * Issue #314: Disabled support for ``setup_requires`` metadata to avoid issue where Setuptools was unable to upgrade over earlier versions. 8.4 === * BB Pull Request #106: Now write ``setup_requires`` metadata. 8.3 === * Issue #311: Decoupled pkg_resources from setuptools once again. ``pkg_resources`` is now a package instead of a module. 8.2.1 ===== * Issue #306: Suppress warnings about Version format except in select scenarios (such as installation). 8.2 === * BB Pull Request #85: Search egg-base when adding egg-info to manifest. 8.1 === * Upgrade ``packaging`` to 14.5, giving preference to "rc" as designator for release candidates over "c". * PEP-440 warnings are now raised as their own class, ``pkg_resources.PEP440Warning``, instead of RuntimeWarning. * Disabled warnings on empty versions. 8.0.4 ===== * Upgrade ``packaging`` to 14.4, fixing an error where there is a different result for if 2.0.5 is contained within >2.0dev and >2.0.dev even though normalization rules should have made them equal. * Issue #296: Add warning when a version is parsed as legacy. This warning will make it easier for developers to recognize deprecated version numbers. 8.0.3 ===== * Issue #296: Restored support for ``__hash__`` on parse_version results. 8.0.2 ===== * Issue #296: Restored support for ``__getitem__`` and sort operations on parse_version result. 8.0.1 ===== * Issue #296: Restore support for iteration over parse_version result, but deprecated that usage with a warning. Fixes failure with buildout. 8.0 === * Implement PEP 440 within pkg_resources and setuptools. This change deprecates some version numbers such that they will no longer be installable without using the ``===`` escape hatch. See `the changes to test_resources `_ for specific examples of version numbers and specifiers that are no longer supported. Setuptools now "vendors" the `packaging `_ library. 7.0 === * Issue #80, Issue #209: Eggs that are downloaded for ``setup_requires``, ``test_requires``, etc. are now placed in a ``./.eggs`` directory instead of directly in the current directory. This choice of location means the files can be readily managed (removed, ignored). Additionally, later phases or invocations of setuptools will not detect the package as already installed and ignore it for permanent install (See #209). This change is indicated as backward-incompatible as installations that depend on the installation in the current directory will need to account for the new location. Systems that ignore ``*.egg`` will probably need to be adapted to ignore ``.eggs``. The files will need to be manually moved or will be retrieved again. Most use cases will require no attention. 6.1 === * Issue #268: When resolving package versions, a VersionConflict now reports which package previously required the conflicting version. 6.0.2 ===== * Issue #262: Fixed regression in pip install due to egg-info directories being omitted. Re-opens Issue #118. 6.0.1 ===== * Issue #259: Fixed regression with namespace package handling on ``single version, externally managed`` installs. 6.0 === * Issue #100: When building a distribution, Setuptools will no longer match default files using platform-dependent case sensitivity, but rather will only match the files if their case matches exactly. As a result, on Windows and other case-insensitive file systems, files with names such as 'readme.txt' or 'README.TXT' will be omitted from the distribution and a warning will be issued indicating that 'README.txt' was not found. Other filenames affected are: - README.rst - README - setup.cfg - setup.py (or the script name) - test/test*.py Any users producing distributions with filenames that match those above case-insensitively, but not case-sensitively, should rename those files in their repository for better portability. * BB Pull Request #72: When using ``single_version_externally_managed``, the exclusion list now includes Python 3.2 ``__pycache__`` entries. * BB Pull Request #76 and BB Pull Request #78: lines in top_level.txt are now ordered deterministically. * Issue #118: The egg-info directory is now no longer included in the list of outputs. * Issue #258: Setuptools now patches distutils msvc9compiler to recognize the specially-packaged compiler package for easy extension module support on Python 2.6, 2.7, and 3.2. 5.8 === * Issue #237: ``pkg_resources`` now uses explicit detection of Python 2 vs. Python 3, supporting environments where builtins have been patched to make Python 3 look more like Python 2. 5.7 === * Issue #240: Based on real-world performance measures against 5.4, zip manifests are now cached in all circumstances. The ``PKG_RESOURCES_CACHE_ZIP_MANIFESTS`` environment variable is no longer relevant. The observed "memory increase" referenced in the 5.4 release notes and detailed in Issue #154 was likely not an increase over the status quo, but rather only an increase over not storing the zip info at all. 5.6 === * Issue #242: Use absolute imports in svn_utils to avoid issues if the installing package adds an xml module to the path. 5.5.1 ===== * Issue #239: Fix typo in 5.5 such that fix did not take. 5.5 === * Issue #239: Setuptools now includes the setup_requires directive on Distribution objects and validates the syntax just like install_requires and tests_require directives. 5.4.2 ===== * Issue #236: Corrected regression in execfile implementation for Python 2.6. 5.4.1 ===== * Python #7776: (ssl_support) Correct usage of host for validation when tunneling for HTTPS. 5.4 === * Issue #154: ``pkg_resources`` will now cache the zip manifests rather than re-processing the same file from disk multiple times, but only if the environment variable ``PKG_RESOURCES_CACHE_ZIP_MANIFESTS`` is set. Clients that package many modules in the same zip file will see some improvement in startup time by enabling this feature. This feature is not enabled by default because it causes a substantial increase in memory usage. 5.3 === * Issue #185: Make svn tagging work on the new style SVN metadata. Thanks cazabon! * Prune revision control directories (e.g .svn) from base path as well as sub-directories. 5.2 === * Added a `Developer Guide `_ to the official documentation. * Some code refactoring and cleanup was done with no intended behavioral changes. * During install_egg_info, the generated lines for namespace package .pth files are now processed even during a dry run. 5.1 === * Issue #202: Implemented more robust cache invalidation for the ZipImporter, building on the work in Issue #168. Special thanks to Jurko Gospodnetic and PJE. 5.0.2 ===== * Issue #220: Restored script templates. 5.0.1 ===== * Renamed script templates to end with .tmpl now that they no longer need to be processed by 2to3. Fixes spurious syntax errors during build/install. 5.0 === * Issue #218: Re-release of 3.8.1 to signal that it supersedes 4.x. * Incidentally, script templates were updated not to include the triple-quote escaping. 3.7.1 and 3.8.1 and 4.0.1 ========================= * Issue #213: Use legacy StringIO behavior for compatibility under pbr. * Issue #218: Setuptools 3.8.1 superseded 4.0.1, and 4.x was removed from the available versions to install. 4.0 === * Issue #210: ``setup.py develop`` now copies scripts in binary mode rather than text mode, matching the behavior of the ``install`` command. 3.8 === * Extend Issue #197 workaround to include all Python 3 versions prior to 3.2.2. 3.7 === * Issue #193: Improved handling of Unicode filenames when building manifests. 3.6 === * Issue #203: Honor proxy settings for Powershell downloader in the bootstrap routine. 3.5.2 ===== * Issue #168: More robust handling of replaced zip files and stale caches. Fixes ZipImportError complaining about a 'bad local header'. 3.5.1 ===== * Issue #199: Restored ``install._install`` for compatibility with earlier NumPy versions. 3.5 === * Issue #195: Follow symbolic links in find_packages (restoring behavior broken in 3.4). * Issue #197: On Python 3.1, PKG-INFO is now saved in a UTF-8 encoding instead of ``sys.getpreferredencoding`` to match the behavior on Python 2.6-3.4. * Issue #192: Preferred bootstrap location is now https://bootstrap.pypa.io/ez_setup.py (mirrored from former location). 3.4.4 ===== * Issue #184: Correct failure where find_package over-matched packages when directory traversal isn't short-circuited. 3.4.3 ===== * Issue #183: Really fix test command with Python 3.1. 3.4.2 ===== * Issue #183: Fix additional regression in test command on Python 3.1. 3.4.1 ===== * Issue #180: Fix regression in test command not caught by py.test-run tests. 3.4 === * Issue #176: Add parameter to the test command to support a custom test runner: --test-runner or -r. * Issue #177: Now assume most common invocation to install command on platforms/environments without stack support (issuing a warning). Setuptools now installs naturally on IronPython. Behavior on CPython should be unchanged. 3.3 === * Add ``include`` parameter to ``setuptools.find_packages()``. 3.2 === * BB Pull Request #39: Add support for C++ targets from Cython ``.pyx`` files. * Issue #162: Update dependency on certifi to 1.0.1. * Issue #164: Update dependency on wincertstore to 0.2. 3.1 === * Issue #161: Restore Features functionality to allow backward compatibility (for Features) until the uses of that functionality is sufficiently removed. 3.0.2 ===== * Correct typo in previous bugfix. 3.0.1 ===== * Issue #157: Restore support for Python 2.6 in bootstrap script where ``zipfile.ZipFile`` does not yet have support for context managers. 3.0 === * Issue #125: Prevent Subversion support from creating a ~/.subversion directory just for checking the presence of a Subversion repository. * Issue #12: Namespace packages are now imported lazily. That is, the mere declaration of a namespace package in an egg on ``sys.path`` no longer causes it to be imported when ``pkg_resources`` is imported. Note that this change means that all of a namespace package's ``__init__.py`` files must include a ``declare_namespace()`` call in order to ensure that they will be handled properly at runtime. In 2.x it was possible to get away without including the declaration, but only at the cost of forcing namespace packages to be imported early, which 3.0 no longer does. * Issue #148: When building (bdist_egg), setuptools no longer adds ``__init__.py`` files to namespace packages. Any packages that rely on this behavior will need to create ``__init__.py`` files and include the ``declare_namespace()``. * Issue #7: Setuptools itself is now distributed as a zip archive in addition to tar archive. ez_setup.py now uses zip archive. This approach avoids the potential security vulnerabilities presented by use of tar archives in ez_setup.py. It also leverages the security features added to ZipFile.extract in Python 2.7.4. * Issue #65: Removed deprecated Features functionality. * BB Pull Request #28: Remove backport of ``_bytecode_filenames`` which is available in Python 2.6 and later, but also has better compatibility with Python 3 environments. * Issue #156: Fix spelling of __PYVENV_LAUNCHER__ variable. 2.2 === * Issue #141: Restored fix for allowing setup_requires dependencies to override installed dependencies during setup. * Issue #128: Fixed issue where only the first dependency link was honored in a distribution where multiple dependency links were supplied. 2.1.2 ===== * Issue #144: Read long_description using codecs module to avoid errors installing on systems where LANG=C. 2.1.1 ===== * Issue #139: Fix regression in re_finder for CVS repos (and maybe Git repos as well). 2.1 === * Issue #129: Suppress inspection of ``*.whl`` files when searching for files in a zip-imported file. * Issue #131: Fix RuntimeError when constructing an egg fetcher. 2.0.2 ===== * Fix NameError during installation with Python implementations (e.g. Jython) not containing parser module. * Fix NameError in ``sdist:re_finder``. 2.0.1 ===== * Issue #124: Fixed error in list detection in upload_docs. 2.0 === * Issue #121: Exempt lib2to3 pickled grammars from DirectorySandbox. * Issue #41: Dropped support for Python 2.4 and Python 2.5. Clients requiring setuptools for those versions of Python should use setuptools 1.x. * Removed ``setuptools.command.easy_install.HAS_USER_SITE``. Clients expecting this boolean variable should use ``site.ENABLE_USER_SITE`` instead. * Removed ``pkg_resources.ImpWrapper``. Clients that expected this class should use ``pkgutil.ImpImporter`` instead. 1.4.2 ===== * Issue #116: Correct TypeError when reading a local package index on Python 3. 1.4.1 ===== * Issue #114: Use ``sys.getfilesystemencoding`` for decoding config in ``bdist_wininst`` distributions. * Issue #105 and Issue #113: Establish a more robust technique for determining the terminal encoding:: 1. Try ``getpreferredencoding`` 2. If that returns US_ASCII or None, try the encoding from ``getdefaultlocale``. If that encoding was a "fallback" because Python could not figure it out from the environment or OS, encoding remains unresolved. 3. If the encoding is resolved, then make sure Python actually implements the encoding. 4. On the event of an error or unknown codec, revert to fallbacks (UTF-8 on Darwin, ASCII on everything else). 5. On the encoding is 'mac-roman' on Darwin, use UTF-8 as 'mac-roman' was a bug on older Python releases. On a side note, it would seem that the encoding only matters for when SVN does not yet support ``--xml`` and when getting repository and svn version numbers. The ``--xml`` technique should yield UTF-8 according to some messages on the SVN mailing lists. So if the version numbers are always 7-bit ASCII clean, it may be best to only support the file parsing methods for legacy SVN releases and support for SVN without the subprocess command would simple go away as support for the older SVNs does. 1.4 === * Issue #27: ``easy_install`` will now use credentials from .pypirc if present for connecting to the package index. * BB Pull Request #21: Omit unwanted newlines in ``package_index._encode_auth`` when the username/password pair length indicates wrapping. 1.3.2 ===== * Issue #99: Fix filename encoding issues in SVN support. 1.3.1 ===== * Remove exuberant warning in SVN support when SVN is not used. 1.3 === * Address security vulnerability in SSL match_hostname check as reported in Python #17997. * Prefer :pypi:`backports.ssl_match_hostname` for backport implementation if present. * Correct NameError in ``ssl_support`` module (``socket.error``). 1.2 === * Issue #26: Add support for SVN 1.7. Special thanks to Philip Thiem for the contribution. * Issue #93: Wheels are now distributed with every release. Note that as reported in Issue #108, as of Pip 1.4, scripts aren't installed properly from wheels. Therefore, if using Pip to install setuptools from a wheel, the ``easy_install`` command will not be available. * Setuptools "natural" launcher support, introduced in 1.0, is now officially supported. 1.1.7 ===== * Fixed behavior of NameError handling in 'script template (dev).py' (script launcher for 'develop' installs). * ``ez_setup.py`` now ensures partial downloads are cleaned up following a failed download. * Distribute #363 and Issue #55: Skip an sdist test that fails on locales other than UTF-8. 1.1.6 ===== * Distribute #349: ``sandbox.execfile`` now opens the target file in binary mode, thus honoring a BOM in the file when compiled. 1.1.5 ===== * Issue #69: Second attempt at fix (logic was reversed). 1.1.4 ===== * Issue #77: Fix error in upload command (Python 2.4). 1.1.3 ===== * Fix NameError in previous patch. 1.1.2 ===== * Issue #69: Correct issue where 404 errors are returned for URLs with fragments in them (such as #egg=). 1.1.1 ===== * Issue #75: Add ``--insecure`` option to ez_setup.py to accommodate environments where a trusted SSL connection cannot be validated. * Issue #76: Fix AttributeError in upload command with Python 2.4. 1.1 === * Issue #71 (Distribute #333): EasyInstall now puts less emphasis on the condition when a host is blocked via ``--allow-hosts``. * Issue #72: Restored Python 2.4 compatibility in ``ez_setup.py``. 1.0 === * Issue #60: On Windows, Setuptools supports deferring to another launcher, such as Vinay Sajip's `pylauncher `_ (included with Python 3.3) to launch console and GUI scripts and not install its own launcher executables. This experimental functionality is currently only enabled if the ``SETUPTOOLS_LAUNCHER`` environment variable is set to "natural". In the future, this behavior may become default, but only after it has matured and seen substantial adoption. The ``SETUPTOOLS_LAUNCHER`` also accepts "executable" to force the default behavior of creating launcher executables. * Issue #63: Bootstrap script (ez_setup.py) now prefers Powershell, curl, or wget for retrieving the Setuptools tarball for improved security of the install. The script will still fall back to a simple ``urlopen`` on platforms that do not have these tools. * Issue #65: Deprecated the ``Features`` functionality. * Issue #52: In ``VerifyingHTTPSConn``, handle a tunnelled (proxied) connection. Backward-Incompatible Changes ----------------------------- This release includes a couple of backward-incompatible changes, but most if not all users will find 1.0 a drop-in replacement for 0.9. * Issue #50: Normalized API of environment marker support. Specifically, removed line number and filename from SyntaxErrors when returned from ``pkg_resources.invalid_marker``. Any clients depending on the specific string representation of exceptions returned by that function may need to be updated to account for this change. * Issue #50: SyntaxErrors generated by ``pkg_resources.invalid_marker`` are normalized for cross-implementation consistency. * Removed ``--ignore-conflicts-at-my-risk`` and ``--delete-conflicting`` options to easy_install. These options have been deprecated since 0.6a11. 0.9.8 ===== * Issue #53: Fix NameErrors in ``_vcs_split_rev_from_url``. 0.9.7 ===== * Issue #49: Correct AttributeError on PyPy where a hashlib.HASH object does not have a ``.name`` attribute. * Issue #34: Documentation now refers to bootstrap script in code repository referenced by bookmark. * Add underscore-separated keys to environment markers (markerlib). 0.9.6 ===== * Issue #44: Test failure on Python 2.4 when MD5 hash doesn't have a ``.name`` attribute. 0.9.5 ===== * Python #17980: Fix security vulnerability in SSL certificate validation. 0.9.4 ===== * Issue #43: Fix issue (introduced in 0.9.1) with version resolution when upgrading over other releases of Setuptools. 0.9.3 ===== * Issue #42: Fix new ``AttributeError`` introduced in last fix. 0.9.2 ===== * Issue #42: Fix regression where blank checksums would trigger an ``AttributeError``. 0.9.1 ===== * Distribute #386: Allow other positional and keyword arguments to os.open. * Corrected dependency on certifi mis-referenced in 0.9. 0.9 === * ``package_index`` now validates hashes other than MD5 in download links. 0.8 === * Code base now runs on Python 2.4 - Python 3.3 without Python 2to3 conversion. 0.7.8 ===== * Distribute #375: Yet another fix for yet another regression. 0.7.7 ===== * Distribute #375: Repair AttributeError created in last release (redo). * Issue #30: Added test for get_cache_path. 0.7.6 ===== * Distribute #375: Repair AttributeError created in last release. 0.7.5 ===== * Issue #21: Restore Python 2.4 compatibility in ``test_easy_install``. * Distribute #375: Merged additional warning from Distribute 0.6.46. * Now honor the environment variable ``SETUPTOOLS_DISABLE_VERSIONED_EASY_INSTALL_SCRIPT`` in addition to the now deprecated ``DISTRIBUTE_DISABLE_VERSIONED_EASY_INSTALL_SCRIPT``. 0.7.4 ===== * Issue #20: Fix comparison of parsed SVN version on Python 3. 0.7.3 ===== * Issue #1: Disable installation of Windows-specific files on non-Windows systems. * Use new sysconfig module with Python 2.7 or >=3.2. 0.7.2 ===== * Issue #14: Use markerlib when the ``parser`` module is not available. * Issue #10: ``ez_setup.py`` now uses HTTPS to download setuptools from PyPI. 0.7.1 ===== * Fix NameError (Issue #3) again - broken in bad merge. 0.7 === * Merged Setuptools and Distribute. See docs/merge.txt for details. Added several features that were slated for setuptools 0.6c12: * Index URL now defaults to HTTPS. * Added experimental environment marker support. Now clients may designate a PEP-426 environment marker for "extra" dependencies. Setuptools uses this feature in ``setup.py`` for optional SSL and certificate validation support on older platforms. Based on Distutils-SIG discussions, the syntax is somewhat tentative. There should probably be a PEP with a firmer spec before the feature should be considered suitable for use. * Added support for SSL certificate validation when installing packages from an HTTPS service. 0.7b4 ===== * Issue #3: Fixed NameError in SSL support. 0.6.49 ====== * Move warning check in ``get_cache_path`` to follow the directory creation to avoid errors when the cache path does not yet exist. Fixes the error reported in Distribute #375. 0.6.48 ====== * Correct AttributeError in ``ResourceManager.get_cache_path`` introduced in 0.6.46 (redo). 0.6.47 ====== * Correct AttributeError in ``ResourceManager.get_cache_path`` introduced in 0.6.46. 0.6.46 ====== * Distribute #375: Issue a warning if the PYTHON_EGG_CACHE or otherwise customized egg cache location specifies a directory that's group- or world-writable. 0.6.45 ====== * Distribute #379: ``distribute_setup.py`` now traps VersionConflict as well, restoring ability to upgrade from an older setuptools version. 0.6.44 ====== * ``distribute_setup.py`` has been updated to allow Setuptools 0.7 to satisfy use_setuptools. 0.6.43 ====== * Distribute #378: Restore support for Python 2.4 Syntax (regression in 0.6.42). 0.6.42 ====== * External links finder no longer yields duplicate links. * Distribute #337: Moved site.py to setuptools/site-patch.py (graft of very old patch from setuptools trunk which inspired PR #31). 0.6.41 ====== * Distribute #27: Use public api for loading resources from zip files rather than the private method ``_zip_directory_cache``. * Added a new function ``easy_install.get_win_launcher`` which may be used by third-party libraries such as buildout to get a suitable script launcher. 0.6.40 ====== * Distribute #376: brought back cli.exe and gui.exe that were deleted in the previous release. 0.6.39 ====== * Add support for console launchers on ARM platforms. * Fix possible issue in GUI launchers where the subsystem was not supplied to the linker. * Launcher build script now refactored for robustness. * Distribute #375: Resources extracted from a zip egg to the file system now also check the contents of the file against the zip contents during each invocation of get_resource_filename. 0.6.38 ====== * Distribute #371: The launcher manifest file is now installed properly. 0.6.37 ====== * Distribute #143: Launcher scripts, including easy_install itself, are now accompanied by a manifest on 32-bit Windows environments to avoid the Installer Detection Technology and thus undesirable UAC elevation described in `this Microsoft article `_. 0.6.36 ====== * BB Pull Request #35: In Buildout #64, it was reported that under Python 3, installation of distutils scripts could attempt to copy the ``__pycache__`` directory as a file, causing an error, apparently only under Windows. Easy_install now skips all directories when processing metadata scripts. 0.6.35 ====== Note this release is backward-incompatible with distribute 0.6.23-0.6.34 in how it parses version numbers. * Distribute #278: Restored compatibility with distribute 0.6.22 and setuptools 0.6. Updated the documentation to match more closely with the version parsing as intended in setuptools 0.6. 0.6.34 ====== * Distribute #341: 0.6.33 fails to build under Python 2.4. 0.6.33 ====== * Fix 2 errors with Jython 2.5. * Fix 1 failure with Jython 2.5 and 2.7. * Disable workaround for Jython scripts on Linux systems. * Distribute #336: ``setup.py`` no longer masks failure exit code when tests fail. * Fix issue in pkg_resources where try/except around a platform-dependent import would trigger hook load failures on Mercurial. See pull request 32 for details. * Distribute #341: Fix a ResourceWarning. 0.6.32 ====== * Fix test suite with Python 2.6. * Fix some DeprecationWarnings and ResourceWarnings. * Distribute #335: Backed out ``setup_requires`` superseding installed requirements until regression can be addressed. 0.6.31 ====== * Distribute #303: Make sure the manifest only ever contains UTF-8 in Python 3. * Distribute #329: Properly close files created by tests for compatibility with Jython. * Work around Jython #1980 and Jython #1981. * Distribute #334: Provide workaround for packages that reference ``sys.__stdout__`` such as numpy does. This change should address pypa/virtualenv#359 as long as the system encoding is UTF-8 or the IO encoding is specified in the environment, i.e.:: PYTHONIOENCODING=utf8 pip install numpy * Fix for encoding issue when installing from Windows executable on Python 3. * Distribute #323: Allow ``setup_requires`` requirements to supersede installed requirements. Added some new keyword arguments to existing pkg_resources methods. Also had to updated how __path__ is handled for namespace packages to ensure that when a new egg distribution containing a namespace package is placed on sys.path, the entries in __path__ are found in the same order they would have been in had that egg been on the path when pkg_resources was first imported. 0.6.30 ====== * Distribute #328: Clean up temporary directories in distribute_setup.py. * Fix fatal bug in distribute_setup.py. 0.6.29 ====== * BB Pull Request #14: Honor file permissions in zip files. * Distribute #327: Merged pull request #24 to fix a dependency problem with pip. * Merged pull request #23 to fix pypa/virtualenv#301. * If Sphinx is installed, the ``upload_docs`` command now runs ``build_sphinx`` to produce uploadable documentation. * Distribute #326: ``upload_docs`` provided mangled auth credentials under Python 3. * Distribute #320: Fix check for "creatable" in distribute_setup.py. * Distribute #305: Remove a warning that was triggered during normal operations. * Distribute #311: Print metadata in UTF-8 independent of platform. * Distribute #303: Read manifest file with UTF-8 encoding under Python 3. * Distribute #301: Allow to run tests of namespace packages when using 2to3. * Distribute #304: Prevent import loop in site.py under Python 3.3. * Distribute #283: Re-enable scanning of ``*.pyc`` / ``*.pyo`` files on Python 3.3. * Distribute #299: The develop command didn't work on Python 3, when using 2to3, as the egg link would go to the Python 2 source. Linking to the 2to3'd code in build/lib makes it work, although you will have to rebuild the module before testing it. * Distribute #306: Even if 2to3 is used, we build in-place under Python 2. * Distribute #307: Prints the full path when .svn/entries is broken. * Distribute #313: Support for sdist subcommands (Python 2.7) * Distribute #314: test_local_index() would fail an OS X. * Distribute #310: Non-ascii characters in a namespace __init__.py causes errors. * Distribute #218: Improved documentation on behavior of ``package_data`` and ``include_package_data``. Files indicated by ``package_data`` are now included in the manifest. * ``distribute_setup.py`` now allows a ``--download-base`` argument for retrieving distribute from a specified location. 0.6.28 ====== * Distribute #294: setup.py can now be invoked from any directory. * Scripts are now installed honoring the umask. * Added support for .dist-info directories. * Distribute #283: Fix and disable scanning of ``*.pyc`` / ``*.pyo`` files on Python 3.3. 0.6.27 ====== * Support current snapshots of CPython 3.3. * Distribute now recognizes README.rst as a standard, default readme file. * Exclude 'encodings' modules when removing modules from sys.modules. Workaround for #285. * Distribute #231: Don't fiddle with system python when used with buildout (bootstrap.py) 0.6.26 ====== * Distribute #183: Symlinked files are now extracted from source distributions. * Distribute #227: Easy_install fetch parameters are now passed during the installation of a source distribution; now fulfillment of setup_requires dependencies will honor the parameters passed to easy_install. 0.6.25 ====== * Distribute #258: Workaround a cache issue * Distribute #260: distribute_setup.py now accepts the --user parameter for Python 2.6 and later. * Distribute #262: package_index.open_with_auth no longer throws LookupError on Python 3. * Distribute #269: AttributeError when an exception occurs reading Manifest.in on late releases of Python. * Distribute #272: Prevent TypeError when namespace package names are unicode and single-install-externally-managed is used. Also fixes PIP issue 449. * Distribute #273: Legacy script launchers now install with Python2/3 support. 0.6.24 ====== * Distribute #249: Added options to exclude 2to3 fixers 0.6.23 ====== * Distribute #244: Fixed a test * Distribute #243: Fixed a test * Distribute #239: Fixed a test * Distribute #240: Fixed a test * Distribute #241: Fixed a test * Distribute #237: Fixed a test * Distribute #238: easy_install now uses 64bit executable wrappers on 64bit Python * Distribute #208: Fixed parsed_versions, it now honors post-releases as noted in the documentation * Distribute #207: Windows cli and gui wrappers pass CTRL-C to child python process * Distribute #227: easy_install now passes its arguments to setup.py bdist_egg * Distribute #225: Fixed a NameError on Python 2.5, 2.4 0.6.21 ====== * Distribute #225: FIxed a regression on py2.4 0.6.20 ====== * Distribute #135: Include url in warning when processing URLs in package_index. * Distribute #212: Fix issue where easy_instal fails on Python 3 on windows installer. * Distribute #213: Fix typo in documentation. 0.6.19 ====== * Distribute #206: AttributeError: 'HTTPMessage' object has no attribute 'getheaders' 0.6.18 ====== * Distribute #210: Fixed a regression introduced by Distribute #204 fix. 0.6.17 ====== * Support 'DISTRIBUTE_DISABLE_VERSIONED_EASY_INSTALL_SCRIPT' environment variable to allow to disable installation of easy_install-${version} script. * Support Python >=3.1.4 and >=3.2.1. * Distribute #204: Don't try to import the parent of a namespace package in declare_namespace * Distribute #196: Tolerate responses with multiple Content-Length headers * Distribute #205: Sandboxing doesn't preserve working_set. Leads to setup_requires problems. 0.6.16 ====== * Builds sdist gztar even on Windows (avoiding Distribute #193). * Distribute #192: Fixed metadata omitted on Windows when package_dir specified with forward-slash. * Distribute #195: Cython build support. * Distribute #200: Issues with recognizing 64-bit packages on Windows. 0.6.15 ====== * Fixed typo in bdist_egg * Several issues under Python 3 has been solved. * Distribute #146: Fixed missing DLL files after easy_install of windows exe package. 0.6.14 ====== * Distribute #170: Fixed unittest failure. Thanks to Toshio. * Distribute #171: Fixed race condition in unittests cause deadlocks in test suite. * Distribute #143: Fixed a lookup issue with easy_install. Thanks to David and Zooko. * Distribute #174: Fixed the edit mode when its used with setuptools itself 0.6.13 ====== * Distribute #160: 2.7 gives ValueError("Invalid IPv6 URL") * Distribute #150: Fixed using ~/.local even in a --no-site-packages virtualenv * Distribute #163: scan index links before external links, and don't use the md5 when comparing two distributions 0.6.12 ====== * Distribute #149: Fixed various failures on 2.3/2.4 0.6.11 ====== * Found another case of SandboxViolation - fixed * Distribute #15 and Distribute #48: Introduced a socket timeout of 15 seconds on url openings * Added indexsidebar.html into MANIFEST.in * Distribute #108: Fixed TypeError with Python3.1 * Distribute #121: Fixed --help install command trying to actually install. * Distribute #112: Added an os.makedirs so that Tarek's solution will work. * Distribute #133: Added --no-find-links to easy_install * Added easy_install --user * Distribute #100: Fixed develop --user not taking '.' in PYTHONPATH into account * Distribute #134: removed spurious UserWarnings. Patch by VanLindberg * Distribute #138: cant_write_to_target error when setup_requires is used. * Distribute #147: respect the sys.dont_write_bytecode flag 0.6.10 ====== * Reverted change made for the DistributionNotFound exception because zc.buildout uses the exception message to get the name of the distribution. 0.6.9 ===== * Distribute #90: unknown setuptools version can be added in the working set * Distribute #87: setupt.py doesn't try to convert distribute_setup.py anymore Initial Patch by arfrever. * Distribute #89: added a side bar with a download link to the doc. * Distribute #86: fixed missing sentence in pkg_resources doc. * Added a nicer error message when a DistributionNotFound is raised. * Distribute #80: test_develop now works with Python 3.1 * Distribute #93: upload_docs now works if there is an empty sub-directory. * Distribute #70: exec bit on non-exec files * Distribute #99: now the standalone easy_install command doesn't uses a "setup.cfg" if any exists in the working directory. It will use it only if triggered by ``install_requires`` from a setup.py call (install, develop, etc). * Distribute #101: Allowing ``os.devnull`` in Sandbox * Distribute #92: Fixed the "no eggs" found error with MacPort (platform.mac_ver() fails) * Distribute #103: test_get_script_header_jython_workaround not run anymore under py3 with C or POSIX local. Contributed by Arfrever. * Distribute #104: removed the assertion when the installation fails, with a nicer message for the end user. * Distribute #100: making sure there's no SandboxViolation when the setup script patches setuptools. 0.6.8 ===== * Added "check_packages" in dist. (added in Setuptools 0.6c11) * Fixed the DONT_PATCH_SETUPTOOLS state. 0.6.7 ===== * Distribute #58: Added --user support to the develop command * Distribute #11: Generated scripts now wrap their call to the script entry point in the standard "if name == 'main'" * Added the 'DONT_PATCH_SETUPTOOLS' environment variable, so virtualenv can drive an installation that doesn't patch a global setuptools. * Reviewed unladen-swallow specific change from http://code.google.com/p/unladen-swallow/source/detail?spec=svn875&r=719 and determined that it no longer applies. Distribute should work fine with Unladen Swallow 2009Q3. * Distribute #21: Allow PackageIndex.open_url to gracefully handle all cases of a httplib.HTTPException instead of just InvalidURL and BadStatusLine. * Removed virtual-python.py from this distribution and updated documentation to point to the actively maintained virtualenv instead. * Distribute #64: use_setuptools no longer rebuilds the distribute egg every time it is run * use_setuptools now properly respects the requested version * use_setuptools will no longer try to import a distribute egg for the wrong Python version * Distribute #74: no_fake should be True by default. * Distribute #72: avoid a bootstrapping issue with easy_install -U 0.6.6 ===== * Unified the bootstrap file so it works on both py2.x and py3k without 2to3 (patch by Holger Krekel) 0.6.5 ===== * Distribute #65: cli.exe and gui.exe are now generated at build time, depending on the platform in use. * Distribute #67: Fixed doc typo (PEP 381/PEP 382). * Distribute no longer shadows setuptools if we require a 0.7-series setuptools. And an error is raised when installing a 0.7 setuptools with distribute. * When run from within buildout, no attempt is made to modify an existing setuptools egg, whether in a shared egg directory or a system setuptools. * Fixed a hole in sandboxing allowing builtin file to write outside of the sandbox. 0.6.4 ===== * Added the generation of ``distribute_setup_3k.py`` during the release. This closes Distribute #52. * Added an upload_docs command to easily upload project documentation to PyPI's https://pythonhosted.org. This close issue Distribute #56. * Fixed a bootstrap bug on the use_setuptools() API. 0.6.3 ===== setuptools ---------- * Fixed a bunch of calls to file() that caused crashes on Python 3. bootstrapping ------------- * Fixed a bug in sorting that caused bootstrap to fail on Python 3. 0.6.2 ===== setuptools ---------- * Added Python 3 support; see docs/python3.txt. This closes Old Setuptools #39. * Added option to run 2to3 automatically when installing on Python 3. This closes issue Distribute #31. * Fixed invalid usage of requirement.parse, that broke develop -d. This closes Old Setuptools #44. * Fixed script launcher for 64-bit Windows. This closes Old Setuptools #2. * KeyError when compiling extensions. This closes Old Setuptools #41. bootstrapping ------------- * Fixed bootstrap not working on Windows. This closes issue Distribute #49. * Fixed 2.6 dependencies. This closes issue Distribute #50. * Make sure setuptools is patched when running through easy_install This closes Old Setuptools #40. 0.6.1 ===== setuptools ---------- * package_index.urlopen now catches BadStatusLine and malformed url errors. This closes Distribute #16 and Distribute #18. * zip_ok is now False by default. This closes Old Setuptools #33. * Fixed invalid URL error catching. Old Setuptools #20. * Fixed invalid bootstraping with easy_install installation (Distribute #40). Thanks to Florian Schulze for the help. * Removed buildout/bootstrap.py. A new repository will create a specific bootstrap.py script. bootstrapping ------------- * The bootstrap process leave setuptools alone if detected in the system and --root or --prefix is provided, but is not in the same location. This closes Distribute #10. 0.6 === setuptools ---------- * Packages required at build time where not fully present at install time. This closes Distribute #12. * Protected against failures in tarfile extraction. This closes Distribute #10. * Made Jython api_tests.txt doctest compatible. This closes Distribute #7. * sandbox.py replaced builtin type file with builtin function open. This closes Distribute #6. * Immediately close all file handles. This closes Distribute #3. * Added compatibility with Subversion 1.6. This references Distribute #1. pkg_resources ------------- * Avoid a call to /usr/bin/sw_vers on OSX and use the official platform API instead. Based on a patch from ronaldoussoren. This closes issue #5. * Fixed a SandboxViolation for mkdir that could occur in certain cases. This closes Distribute #13. * Allow to find_on_path on systems with tight permissions to fail gracefully. This closes Distribute #9. * Corrected inconsistency between documentation and code of add_entry. This closes Distribute #8. * Immediately close all file handles. This closes Distribute #3. easy_install ------------ * Immediately close all file handles. This closes Distribute #3. 0.6c9 ===== * Fixed a missing files problem when using Windows source distributions on non-Windows platforms, due to distutils not handling manifest file line endings correctly. * Updated Pyrex support to work with Pyrex 0.9.6 and higher. * Minor changes for Jython compatibility, including skipping tests that can't work on Jython. * Fixed not installing eggs in ``install_requires`` if they were also used for ``setup_requires`` or ``tests_require``. * Fixed not fetching eggs in ``install_requires`` when running tests. * Allow ``ez_setup.use_setuptools()`` to upgrade existing setuptools installations when called from a standalone ``setup.py``. * Added a warning if a namespace package is declared, but its parent package is not also declared as a namespace. * Support Subversion 1.5 * Removed use of deprecated ``md5`` module if ``hashlib`` is available * Fixed ``bdist_wininst upload`` trying to upload the ``.exe`` twice * Fixed ``bdist_egg`` putting a ``native_libs.txt`` in the source package's ``.egg-info``, when it should only be in the built egg's ``EGG-INFO``. * Ensure that _full_name is set on all shared libs before extensions are checked for shared lib usage. (Fixes a bug in the experimental shared library build support.) * Fix to allow unpacked eggs containing native libraries to fail more gracefully under Google App Engine (with an ``ImportError`` loading the C-based module, instead of getting a ``NameError``). * Fixed ``win32.exe`` support for .pth files, so unnecessary directory nesting is flattened out in the resulting egg. (There was a case-sensitivity problem that affected some distributions, notably ``pywin32``.) * Prevent ``--help-commands`` and other junk from showing under Python 2.5 when running ``easy_install --help``. * Fixed GUI scripts sometimes not executing on Windows * Fixed not picking up dependency links from recursive dependencies. * Only make ``.py``, ``.dll`` and ``.so`` files executable when unpacking eggs * Changes for Jython compatibility * Improved error message when a requirement is also a directory name, but the specified directory is not a source package. * Fixed ``--allow-hosts`` option blocking ``file:`` URLs * Fixed HTTP SVN detection failing when the page title included a project name (e.g. on SourceForge-hosted SVN) * Fix Jython script installation to handle ``#!`` lines better when ``sys.executable`` is a script. * Removed use of deprecated ``md5`` module if ``hashlib`` is available * Keep site directories (e.g. ``site-packages``) from being included in ``.pth`` files. 0.6c7 ===== * Fixed ``distutils.filelist.findall()`` crashing on broken symlinks, and ``egg_info`` command failing on new, uncommitted SVN directories. * Fix import problems with nested namespace packages installed via ``--root`` or ``--single-version-externally-managed``, due to the parent package not having the child package as an attribute. * ``ftp:`` download URLs now work correctly. * The default ``--index-url`` is now ``https://pypi.python.org/simple``, to use the Python Package Index's new simpler (and faster!) REST API. 0.6c6 ===== * Added ``--egg-path`` option to ``develop`` command, allowing you to force ``.egg-link`` files to use relative paths (allowing them to be shared across platforms on a networked drive). * Fix not building binary RPMs correctly. * Fix "eggsecutables" (such as setuptools' own egg) only being runnable with bash-compatible shells. * Fix ``#!`` parsing problems in Windows ``.exe`` script wrappers, when there was whitespace inside a quoted argument or at the end of the ``#!`` line (a regression introduced in 0.6c4). * Fix ``test`` command possibly failing if an older version of the project being tested was installed on ``sys.path`` ahead of the test source directory. * Fix ``find_packages()`` treating ``ez_setup`` and directories with ``.`` in their names as packages. * EasyInstall no longer aborts the installation process if a URL it wants to retrieve can't be downloaded, unless the URL is an actual package download. Instead, it issues a warning and tries to keep going. * Fixed distutils-style scripts originally built on Windows having their line endings doubled when installed on any platform. * Added ``--local-snapshots-ok`` flag, to allow building eggs from projects installed using ``setup.py develop``. * Fixed not HTML-decoding URLs scraped from web pages 0.6c5 ===== * Fix uploaded ``bdist_rpm`` packages being described as ``bdist_egg`` packages under Python versions less than 2.5. * Fix uploaded ``bdist_wininst`` packages being described as suitable for "any" version by Python 2.5, even if a ``--target-version`` was specified. * Fixed ``.dll`` files on Cygwin not having executable permissions when an egg is installed unzipped. 0.6c4 ===== * Overhauled Windows script wrapping to support ``bdist_wininst`` better. Scripts installed with ``bdist_wininst`` will always use ``#!python.exe`` or ``#!pythonw.exe`` as the executable name (even when built on non-Windows platforms!), and the wrappers will look for the executable in the script's parent directory (which should find the right version of Python). * Fix ``upload`` command not uploading files built by ``bdist_rpm`` or ``bdist_wininst`` under Python 2.3 and 2.4. * Add support for "eggsecutable" headers: a ``#!/bin/sh`` script that is prepended to an ``.egg`` file to allow it to be run as a script on Unix-ish platforms. (This is mainly so that setuptools itself can have a single-file installer on Unix, without doing multiple downloads, dealing with firewalls, etc.) * Fix problem with empty revision numbers in Subversion 1.4 ``entries`` files * Use cross-platform relative paths in ``easy-install.pth`` when doing ``develop`` and the source directory is a subdirectory of the installation target directory. * Fix a problem installing eggs with a system packaging tool if the project contained an implicit namespace package; for example if the ``setup()`` listed a namespace package ``foo.bar`` without explicitly listing ``foo`` as a namespace package. * Added support for HTTP "Basic" authentication using ``http://user:pass@host`` URLs. If a password-protected page contains links to the same host (and protocol), those links will inherit the credentials used to access the original page. * Removed all special support for Sourceforge mirrors, as Sourceforge's mirror system now works well for non-browser downloads. * Fixed not recognizing ``win32.exe`` installers that included a custom bitmap. * Fixed not allowing ``os.open()`` of paths outside the sandbox, even if they are opened read-only (e.g. reading ``/dev/urandom`` for random numbers, as is done by ``os.urandom()`` on some platforms). * Fixed a problem with ``.pth`` testing on Windows when ``sys.executable`` has a space in it (e.g., the user installed Python to a ``Program Files`` directory). 0.6c3 ===== * Fixed breakages caused by Subversion 1.4's new "working copy" format * You can once again use "python -m easy_install" with Python 2.4 and above. * Python 2.5 compatibility fixes added. 0.6c2 ===== * The ``ez_setup`` module displays the conflicting version of setuptools (and its installation location) when a script requests a version that's not available. * Running ``setup.py develop`` on a setuptools-using project will now install setuptools if needed, instead of only downloading the egg. * Windows script wrappers now support quoted arguments and arguments containing spaces. (Patch contributed by Jim Fulton.) * The ``ez_setup.py`` script now actually works when you put a setuptools ``.egg`` alongside it for bootstrapping an offline machine. * A writable installation directory on ``sys.path`` is no longer required to download and extract a source distribution using ``--editable``. * Generated scripts now use ``-x`` on the ``#!`` line when ``sys.executable`` contains non-ASCII characters, to prevent deprecation warnings about an unspecified encoding when the script is run. 0.6c1 ===== * Fixed ``AttributeError`` when trying to download a ``setup_requires`` dependency when a distribution lacks a ``dependency_links`` setting. * Made ``zip-safe`` and ``not-zip-safe`` flag files contain a single byte, so as to play better with packaging tools that complain about zero-length files. * Made ``setup.py develop`` respect the ``--no-deps`` option, which it previously was ignoring. * Support ``extra_path`` option to ``setup()`` when ``install`` is run in backward-compatibility mode. * Source distributions now always include a ``setup.cfg`` file that explicitly sets ``egg_info`` options such that they produce an identical version number to the source distribution's version number. (Previously, the default version number could be different due to the use of ``--tag-date``, or if the version was overridden on the command line that built the source distribution.) * EasyInstall now includes setuptools version information in the ``User-Agent`` string sent to websites it visits. 0.6b4 ===== * Fix ``register`` not obeying name/version set by ``egg_info`` command, if ``egg_info`` wasn't explicitly run first on the same command line. * Added ``--no-date`` and ``--no-svn-revision`` options to ``egg_info`` command, to allow suppressing tags configured in ``setup.cfg``. * Fixed redundant warnings about missing ``README`` file(s); it should now appear only if you are actually a source distribution. * Fix creating Python wrappers for non-Python scripts * Fix ``ftp://`` directory listing URLs from causing a crash when used in the "Home page" or "Download URL" slots on PyPI. * Fix ``sys.path_importer_cache`` not being updated when an existing zipfile or directory is deleted/overwritten. * Fix not recognizing HTML 404 pages from package indexes. * Allow ``file://`` URLs to be used as a package index. URLs that refer to directories will use an internally-generated directory listing if there is no ``index.html`` file in the directory. * Allow external links in a package index to be specified using ``rel="homepage"`` or ``rel="download"``, without needing the old PyPI-specific visible markup. * Suppressed warning message about possibly-misspelled project name, if an egg or link for that project name has already been seen. 0.6b3 ===== * Fix ``bdist_egg`` not including files in subdirectories of ``.egg-info``. * Allow ``.py`` files found by the ``include_package_data`` option to be automatically included. Remove duplicate data file matches if both ``include_package_data`` and ``package_data`` are used to refer to the same files. * Fix local ``--find-links`` eggs not being copied except with ``--always-copy``. * Fix sometimes not detecting local packages installed outside of "site" directories. * Fix mysterious errors during initial ``setuptools`` install, caused by ``ez_setup`` trying to run ``easy_install`` twice, due to a code fallthru after deleting the egg from which it's running. 0.6b2 ===== * Don't install or update a ``site.py`` patch when installing to a ``PYTHONPATH`` directory with ``--multi-version``, unless an ``easy-install.pth`` file is already in use there. * Construct ``.pth`` file paths in such a way that installing an egg whose name begins with ``import`` doesn't cause a syntax error. * Fixed a bogus warning message that wasn't updated since the 0.5 versions. 0.6b1 ===== * Strip ``module`` from the end of compiled extension modules when computing the name of a ``.py`` loader/wrapper. (Python's import machinery ignores this suffix when searching for an extension module.) * Better ambiguity management: accept ``#egg`` name/version even if processing what appears to be a correctly-named distutils file, and ignore ``.egg`` files with no ``-``, since valid Python ``.egg`` files always have a version number (but Scheme eggs often don't). * Support ``file://`` links to directories in ``--find-links``, so that easy_install can build packages from local source checkouts. * Added automatic retry for Sourceforge mirrors. The new download process is to first just try dl.sourceforge.net, then randomly select mirror IPs and remove ones that fail, until something works. The removed IPs stay removed for the remainder of the run. * Ignore bdist_dumb distributions when looking at download URLs. 0.6a11 ====== * Added ``test_loader`` keyword to support custom test loaders * Added ``setuptools.file_finders`` entry point group to allow implementing revision control plugins. * Added ``--identity`` option to ``upload`` command. * Added ``dependency_links`` to allow specifying URLs for ``--find-links``. * Enhanced test loader to scan packages as well as modules, and call ``additional_tests()`` if present to get non-unittest tests. * Support namespace packages in conjunction with system packagers, by omitting the installation of any ``__init__.py`` files for namespace packages, and adding a special ``.pth`` file to create a working package in ``sys.modules``. * Made ``--single-version-externally-managed`` automatic when ``--root`` is used, so that most system packagers won't require special support for setuptools. * Fixed ``setup_requires``, ``tests_require``, etc. not using ``setup.cfg`` or other configuration files for their option defaults when installing, and also made the install use ``--multi-version`` mode so that the project directory doesn't need to support .pth files. * ``MANIFEST.in`` is now forcibly closed when any errors occur while reading it. Previously, the file could be left open and the actual error would be masked by problems trying to remove the open file on Windows systems. * Process ``dependency_links.txt`` if found in a distribution, by adding the URLs to the list for scanning. * Use relative paths in ``.pth`` files when eggs are being installed to the same directory as the ``.pth`` file. This maximizes portability of the target directory when building applications that contain eggs. * Added ``easy_install-N.N`` script(s) for convenience when using multiple Python versions. * Added automatic handling of installation conflicts. Eggs are now shifted to the front of sys.path, in an order consistent with where they came from, making EasyInstall seamlessly co-operate with system package managers. The ``--delete-conflicting`` and ``--ignore-conflicts-at-my-risk`` options are now no longer necessary, and will generate warnings at the end of a run if you use them. * Don't recursively traverse subdirectories given to ``--find-links``. 0.6a10 ====== * Fixed the ``develop`` command ignoring ``--find-links``. * Added exhaustive testing of the install directory, including a spawn test for ``.pth`` file support, and directory writability/existence checks. This should virtually eliminate the need to set or configure ``--site-dirs``. * Added ``--prefix`` option for more do-what-I-mean-ishness in the absence of RTFM-ing. :) * Enhanced ``PYTHONPATH`` support so that you don't have to put any eggs on it manually to make it work. ``--multi-version`` is no longer a silent default; you must explicitly use it if installing to a non-PYTHONPATH, non-"site" directory. * Expand ``$variables`` used in the ``--site-dirs``, ``--build-directory``, ``--install-dir``, and ``--script-dir`` options, whether on the command line or in configuration files. * Improved SourceForge mirror processing to work faster and be less affected by transient HTML changes made by SourceForge. * PyPI searches now use the exact spelling of requirements specified on the command line or in a project's ``install_requires``. Previously, a normalized form of the name was used, which could lead to unnecessary full-index searches when a project's name had an underscore (``_``) in it. * EasyInstall can now download bare ``.py`` files and wrap them in an egg, as long as you include an ``#egg=name-version`` suffix on the URL, or if the ``.py`` file is listed as the "Download URL" on the project's PyPI page. This allows third parties to "package" trivial Python modules just by linking to them (e.g. from within their own PyPI page or download links page). * The ``--always-copy`` option now skips "system" and "development" eggs since they can't be reliably copied. Note that this may cause EasyInstall to choose an older version of a package than what you expected, or it may cause downloading and installation of a fresh version of what's already installed. * The ``--find-links`` option previously scanned all supplied URLs and directories as early as possible, but now only directories and direct archive links are scanned immediately. URLs are not retrieved unless a package search was already going to go online due to a package not being available locally, or due to the use of the ``--update`` or ``-U`` option. * Fixed the annoying ``--help-commands`` wart. 0.6a9 ===== * The ``sdist`` command no longer uses the traditional ``MANIFEST`` file to create source distributions. ``MANIFEST.in`` is still read and processed, as are the standard defaults and pruning. But the manifest is built inside the project's ``.egg-info`` directory as ``SOURCES.txt``, and it is rebuilt every time the ``egg_info`` command is run. * Added the ``include_package_data`` keyword to ``setup()``, allowing you to automatically include any package data listed in revision control or ``MANIFEST.in`` * Added the ``exclude_package_data`` keyword to ``setup()``, allowing you to trim back files included via the ``package_data`` and ``include_package_data`` options. * Fixed ``--tag-svn-revision`` not working when run from a source distribution. * Added warning for namespace packages with missing ``declare_namespace()`` * Added ``tests_require`` keyword to ``setup()``, so that e.g. packages requiring ``nose`` to run unit tests can make this dependency optional unless the ``test`` command is run. * Made all commands that use ``easy_install`` respect its configuration options, as this was causing some problems with ``setup.py install``. * Added an ``unpack_directory()`` driver to ``setuptools.archive_util``, so that you can process a directory tree through a processing filter as if it were a zipfile or tarfile. * Added an internal ``install_egg_info`` command to use as part of old-style ``install`` operations, that installs an ``.egg-info`` directory with the package. * Added a ``--single-version-externally-managed`` option to the ``install`` command so that you can more easily wrap a "flat" egg in a system package. * Enhanced ``bdist_rpm`` so that it installs single-version eggs that don't rely on a ``.pth`` file. The ``--no-egg`` option has been removed, since all RPMs are now built in a more backwards-compatible format. * Support full roundtrip translation of eggs to and from ``bdist_wininst`` format. Running ``bdist_wininst`` on a setuptools-based package wraps the egg in an .exe that will safely install it as an egg (i.e., with metadata and entry-point wrapper scripts), and ``easy_install`` can turn the .exe back into an ``.egg`` file or directory and install it as such. * Fixed ``.pth`` file processing picking up nested eggs (i.e. ones inside "baskets") when they weren't explicitly listed in the ``.pth`` file. * If more than one URL appears to describe the exact same distribution, prefer the shortest one. This helps to avoid "table of contents" CGI URLs like the ones on effbot.org. * Quote arguments to python.exe (including python's path) to avoid problems when Python (or a script) is installed in a directory whose name contains spaces on Windows. * Support full roundtrip translation of eggs to and from ``bdist_wininst`` format. Running ``bdist_wininst`` on a setuptools-based package wraps the egg in an .exe that will safely install it as an egg (i.e., with metadata and entry-point wrapper scripts), and ``easy_install`` can turn the .exe back into an ``.egg`` file or directory and install it as such. 0.6a8 ===== * Fixed some problems building extensions when Pyrex was installed, especially with Python 2.4 and/or packages using SWIG. * Made ``develop`` command accept all the same options as ``easy_install``, and use the ``easy_install`` command's configuration settings as defaults. * Made ``egg_info --tag-svn-revision`` fall back to extracting the revision number from ``PKG-INFO`` in case it is being run on a source distribution of a snapshot taken from a Subversion-based project. * Automatically detect ``.dll``, ``.so`` and ``.dylib`` files that are being installed as data, adding them to ``native_libs.txt`` automatically. * Fixed some problems with fresh checkouts of projects that don't include ``.egg-info/PKG-INFO`` under revision control and put the project's source code directly in the project directory. If such a package had any requirements that get processed before the ``egg_info`` command can be run, the setup scripts would fail with a "Missing 'Version:' header and/or PKG-INFO file" error, because the egg runtime interpreted the unbuilt metadata in a directory on ``sys.path`` (i.e. the current directory) as being a corrupted egg. Setuptools now monkeypatches the distribution metadata cache to pretend that the egg has valid version information, until it has a chance to make it actually be so (via the ``egg_info`` command). * Update for changed SourceForge mirror format * Fixed not installing dependencies for some packages fetched via Subversion * Fixed dependency installation with ``--always-copy`` not using the same dependency resolution procedure as other operations. * Fixed not fully removing temporary directories on Windows, if a Subversion checkout left read-only files behind * Fixed some problems building extensions when Pyrex was installed, especially with Python 2.4 and/or packages using SWIG. 0.6a7 ===== * Fixed not being able to install Windows script wrappers using Python 2.3 0.6a6 ===== * Added support for "traditional" PYTHONPATH-based non-root installation, and also the convenient ``virtual-python.py`` script, based on a contribution by Ian Bicking. The setuptools egg now contains a hacked ``site`` module that makes the PYTHONPATH-based approach work with .pth files, so that you can get the full EasyInstall feature set on such installations. * Added ``--no-deps`` and ``--allow-hosts`` options. * Improved Windows ``.exe`` script wrappers so that the script can have the same name as a module without confusing Python. * Changed dependency processing so that it's breadth-first, allowing a depender's preferences to override those of a dependee, to prevent conflicts when a lower version is acceptable to the dependee, but not the depender. Also, ensure that currently installed/selected packages aren't given precedence over ones desired by a package being installed, which could cause conflict errors. 0.6a5 ===== * Fixed missing gui/cli .exe files in distribution. Fixed bugs in tests. 0.6a3 ===== * Added ``gui_scripts`` entry point group to allow installing GUI scripts on Windows and other platforms. (The special handling is only for Windows; other platforms are treated the same as for ``console_scripts``.) * Improved error message when trying to use old ways of running ``easy_install``. Removed the ability to run via ``python -m`` or by running ``easy_install.py``; ``easy_install`` is the command to run on all supported platforms. * Improved wrapper script generation and runtime initialization so that a VersionConflict doesn't occur if you later install a competing version of a needed package as the default version of that package. * Fixed a problem parsing version numbers in ``#egg=`` links. 0.6a2 ===== * Added ``console_scripts`` entry point group to allow installing scripts without the need to create separate script files. On Windows, console scripts get an ``.exe`` wrapper so you can just type their name. On other platforms, the scripts are written without a file extension. * EasyInstall can now install "console_scripts" defined by packages that use ``setuptools`` and define appropriate entry points. On Windows, console scripts get an ``.exe`` wrapper so you can just type their name. On other platforms, the scripts are installed without a file extension. * Using ``python -m easy_install`` or running ``easy_install.py`` is now DEPRECATED, since an ``easy_install`` wrapper is now available on all platforms. 0.6a1 ===== * Added support for building "old-style" RPMs that don't install an egg for the target package, using a ``--no-egg`` option. * The ``build_ext`` command now works better when using the ``--inplace`` option and multiple Python versions. It now makes sure that all extensions match the current Python version, even if newer copies were built for a different Python version. * The ``upload`` command no longer attaches an extra ``.zip`` when uploading eggs, as PyPI now supports egg uploads without trickery. * The ``ez_setup`` script/module now displays a warning before downloading the setuptools egg, and attempts to check the downloaded egg against an internal MD5 checksum table. * Fixed the ``--tag-svn-revision`` option of ``egg_info`` not finding the latest revision number; it was using the revision number of the directory containing ``setup.py``, not the highest revision number in the project. * Added ``eager_resources`` setup argument * The ``sdist`` command now recognizes Subversion "deleted file" entries and does not include them in source distributions. * ``setuptools`` now embeds itself more thoroughly into the distutils, so that other distutils extensions (e.g. py2exe, py2app) will subclass setuptools' versions of things, rather than the native distutils ones. * Added ``entry_points`` and ``setup_requires`` arguments to ``setup()``; ``setup_requires`` allows you to automatically find and download packages that are needed in order to *build* your project (as opposed to running it). * ``setuptools`` now finds its commands, ``setup()`` argument validators, and metadata writers using entry points, so that they can be extended by third-party packages. See `Creating distutils Extensions `_ for more details. * The vestigial ``depends`` command has been removed. It was never finished or documented, and never would have worked without EasyInstall - which it pre-dated and was never compatible with. * EasyInstall now does MD5 validation of downloads from PyPI, or from any link that has an "#md5=..." trailer with a 32-digit lowercase hex md5 digest. * EasyInstall now handles symlinks in target directories by removing the link, rather than attempting to overwrite the link's destination. This makes it easier to set up an alternate Python "home" directory (as described in the Non-Root Installation section of the docs). * Added support for handling MacOS platform information in ``.egg`` filenames, based on a contribution by Kevin Dangoor. You may wish to delete and reinstall any eggs whose filename includes "darwin" and "Power_Macintosh", because the format for this platform information has changed so that minor OS X upgrades (such as 10.4.1 to 10.4.2) do not cause eggs built with a previous OS version to become obsolete. * easy_install's dependency processing algorithms have changed. When using ``--always-copy``, it now ensures that dependencies are copied too. When not using ``--always-copy``, it tries to use a single resolution loop, rather than recursing. * Fixed installing extra ``.pyc`` or ``.pyo`` files for scripts with ``.py`` extensions. * Added ``--site-dirs`` option to allow adding custom "site" directories. Made ``easy-install.pth`` work in platform-specific alternate site directories (e.g. ``~/Library/Python/2.x/site-packages`` on Mac OS X). * If you manually delete the current version of a package, the next run of EasyInstall against the target directory will now remove the stray entry from the ``easy-install.pth`` file. * EasyInstall now recognizes URLs with a ``#egg=project_name`` fragment ID as pointing to the named project's source checkout. Such URLs have a lower match precedence than any other kind of distribution, so they'll only be used if they have a higher version number than any other available distribution, or if you use the ``--editable`` option. The ``#egg`` fragment can contain a version if it's formatted as ``#egg=proj-ver``, where ``proj`` is the project name, and ``ver`` is the version number. You *must* use the format for these values that the ``bdist_egg`` command uses; i.e., all non-alphanumeric runs must be condensed to single underscore characters. * Added the ``--editable`` option; see Editing and Viewing Source Packages in the docs. Also, slightly changed the behavior of the ``--build-directory`` option. * Fixed the setup script sandbox facility not recognizing certain paths as valid on case-insensitive platforms. 0.5a12 ====== * The zip-safety scanner now checks for modules that might be used with ``python -m``, and marks them as unsafe for zipping, since Python 2.4 can't handle ``-m`` on zipped modules. * Fix ``python -m easy_install`` not working due to setuptools being installed as a zipfile. Update safety scanner to check for modules that might be used as ``python -m`` scripts. * Misc. fixes for win32.exe support, including changes to support Python 2.4's changed ``bdist_wininst`` format. 0.5a11 ====== * Fix breakage of the "develop" command that was caused by the addition of ``--always-unzip`` to the ``easy_install`` command. 0.5a10 ====== * Put the ``easy_install`` module back in as a module, as it's needed for ``python -m`` to run it! * Allow ``--find-links/-f`` to accept local directories or filenames as well as URLs. 0.5a9 ===== * Include ``svn:externals`` directories in source distributions as well as normal subversion-controlled files and directories. * Added ``exclude=patternlist`` option to ``setuptools.find_packages()`` * Changed --tag-svn-revision to include an "r" in front of the revision number for better readability. * Added ability to build eggs without including source files (except for any scripts, of course), using the ``--exclude-source-files`` option to ``bdist_egg``. * ``setup.py install`` now automatically detects when an "unmanaged" package or module is going to be on ``sys.path`` ahead of a package being installed, thereby preventing the newer version from being imported. If this occurs, a warning message is output to ``sys.stderr``, but installation proceeds anyway. The warning message informs the user what files or directories need deleting, and advises them they can also use EasyInstall (with the ``--delete-conflicting`` option) to do it automatically. * The ``egg_info`` command now adds a ``top_level.txt`` file to the metadata directory that lists all top-level modules and packages in the distribution. This is used by the ``easy_install`` command to find possibly-conflicting "unmanaged" packages when installing the distribution. * Added ``zip_safe`` and ``namespace_packages`` arguments to ``setup()``. Added package analysis to determine zip-safety if the ``zip_safe`` flag is not given, and advise the author regarding what code might need changing. * Fixed the swapped ``-d`` and ``-b`` options of ``bdist_egg``. * EasyInstall now automatically detects when an "unmanaged" package or module is going to be on ``sys.path`` ahead of a package you're installing, thereby preventing the newer version from being imported. By default, it will abort installation to alert you of the problem, but there are also new options (``--delete-conflicting`` and ``--ignore-conflicts-at-my-risk``) available to change the default behavior. (Note: this new feature doesn't take effect for egg files that were built with older ``setuptools`` versions, because they lack the new metadata file required to implement it.) * The ``easy_install`` distutils command now uses ``DistutilsError`` as its base error type for errors that should just issue a message to stderr and exit the program without a traceback. * EasyInstall can now be given a path to a directory containing a setup script, and it will attempt to build and install the package there. * EasyInstall now performs a safety analysis on module contents to determine whether a package is likely to run in zipped form, and displays information about what modules may be doing introspection that would break when running as a zipfile. * Added the ``--always-unzip/-Z`` option, to force unzipping of packages that would ordinarily be considered safe to unzip, and changed the meaning of ``--zip-ok/-z`` to "always leave everything zipped". 0.5a8 ===== * The "egg_info" command now always sets the distribution metadata to "safe" forms of the distribution name and version, so that distribution files will be generated with parseable names (i.e., ones that don't include '-' in the name or version). Also, this means that if you use the various ``--tag`` options of "egg_info", any distributions generated will use the tags in the version, not just egg distributions. * Added support for defining command aliases in distutils configuration files, under the "[aliases]" section. To prevent recursion and to allow aliases to call the command of the same name, a given alias can be expanded only once per command-line invocation. You can define new aliases with the "alias" command, either for the local, global, or per-user configuration. * Added "rotate" command to delete old distribution files, given a set of patterns to match and the number of files to keep. (Keeps the most recently-modified distribution files matching each pattern.) * Added "saveopts" command that saves all command-line options for the current invocation to the local, global, or per-user configuration file. Useful for setting defaults without having to hand-edit a configuration file. * Added a "setopt" command that sets a single option in a specified distutils configuration file. * There is now a separate documentation page for setuptools; revision history that's not specific to EasyInstall has been moved to that page. 0.5a7 ===== * Added "upload" support for egg and source distributions, including a bug fix for "upload" and a temporary workaround for lack of .egg support in PyPI. 0.5a6 ===== * Beefed up the "sdist" command so that if you don't have a MANIFEST.in, it will include all files under revision control (CVS or Subversion) in the current directory, and it will regenerate the list every time you create a source distribution, not just when you tell it to. This should make the default "do what you mean" more often than the distutils' default behavior did, while still retaining the old behavior in the presence of MANIFEST.in. * Fixed the "develop" command always updating .pth files, even if you specified ``-n`` or ``--dry-run``. * Slightly changed the format of the generated version when you use ``--tag-build`` on the "egg_info" command, so that you can make tagged revisions compare *lower* than the version specified in setup.py (e.g. by using ``--tag-build=dev``). 0.5a5 ===== * Added ``develop`` command to ``setuptools``-based packages. This command installs an ``.egg-link`` pointing to the package's source directory, and script wrappers that ``execfile()`` the source versions of the package's scripts. This lets you put your development checkout(s) on sys.path without having to actually install them. (To uninstall the link, use use ``setup.py develop --uninstall``.) * Added ``egg_info`` command to ``setuptools``-based packages. This command just creates or updates the "projectname.egg-info" directory, without building an egg. (It's used by the ``bdist_egg``, ``test``, and ``develop`` commands.) * Enhanced the ``test`` command so that it doesn't install the package, but instead builds any C extensions in-place, updates the ``.egg-info`` metadata, adds the source directory to ``sys.path``, and runs the tests directly on the source. This avoids an "unmanaged" installation of the package to ``site-packages`` or elsewhere. * Made ``easy_install`` a standard ``setuptools`` command, moving it from the ``easy_install`` module to ``setuptools.command.easy_install``. Note that if you were importing or extending it, you must now change your imports accordingly. ``easy_install.py`` is still installed as a script, but not as a module. 0.5a4 ===== * Setup scripts using setuptools can now list their dependencies directly in the setup.py file, without having to manually create a ``depends.txt`` file. The ``install_requires`` and ``extras_require`` arguments to ``setup()`` are used to create a dependencies file automatically. If you are manually creating ``depends.txt`` right now, please switch to using these setup arguments as soon as practical, because ``depends.txt`` support will be removed in the 0.6 release cycle. For documentation on the new arguments, see the ``setuptools.dist.Distribution`` class. * Setup scripts using setuptools now always install using ``easy_install`` internally, for ease of uninstallation and upgrading. * Added ``--always-copy/-a`` option to always copy needed packages to the installation directory, even if they're already present elsewhere on sys.path. (In previous versions, this was the default behavior, but now you must request it.) * Added ``--upgrade/-U`` option to force checking PyPI for latest available version(s) of all packages requested by name and version, even if a matching version is available locally. * Added automatic installation of dependencies declared by a distribution being installed. These dependencies must be listed in the distribution's ``EGG-INFO`` directory, so the distribution has to have declared its dependencies by using setuptools. If a package has requirements it didn't declare, you'll still have to deal with them yourself. (E.g., by asking EasyInstall to find and install them.) * Added the ``--record`` option to ``easy_install`` for the benefit of tools that run ``setup.py install --record=filename`` on behalf of another packaging system.) 0.5a3 ===== * Fixed not setting script permissions to allow execution. * Improved sandboxing so that setup scripts that want a temporary directory (e.g. pychecker) can still run in the sandbox. 0.5a2 ===== * Fix stupid stupid refactoring-at-the-last-minute typos. :( 0.5a1 ===== * Added support for "self-installation" bootstrapping. Packages can now include ``ez_setup.py`` in their source distribution, and add the following to their ``setup.py``, in order to automatically bootstrap installation of setuptools as part of their setup process:: from ez_setup import use_setuptools use_setuptools() from setuptools import setup # etc... * Added support for converting ``.win32.exe`` installers to eggs on the fly. EasyInstall will now recognize such files by name and install them. * Fixed a problem with picking the "best" version to install (versions were being sorted as strings, rather than as parsed values) 0.4a4 ===== * Added support for the distutils "verbose/quiet" and "dry-run" options, as well as the "optimize" flag. * Support downloading packages that were uploaded to PyPI (by scanning all links on package pages, not just the homepage/download links). 0.4a3 ===== * Add progress messages to the search/download process so that you can tell what URLs it's reading to find download links. (Hopefully, this will help people report out-of-date and broken links to package authors, and to tell when they've asked for a package that doesn't exist.) 0.4a2 ===== * Added ``ez_setup.py`` installer/bootstrap script to make initial setuptools installation easier, and to allow distributions using setuptools to avoid having to include setuptools in their source distribution. * All downloads are now managed by the ``PackageIndex`` class (which is now subclassable and replaceable), so that embedders can more easily override download logic, give download progress reports, etc. The class has also been moved to the new ``setuptools.package_index`` module. * The ``Installer`` class no longer handles downloading, manages a temporary directory, or tracks the ``zip_ok`` option. Downloading is now handled by ``PackageIndex``, and ``Installer`` has become an ``easy_install`` command class based on ``setuptools.Command``. * There is a new ``setuptools.sandbox.run_setup()`` API to invoke a setup script in a directory sandbox, and a new ``setuptools.archive_util`` module with an ``unpack_archive()`` API. These were split out of EasyInstall to allow reuse by other tools and applications. * ``setuptools.Command`` now supports reinitializing commands using keyword arguments to set/reset options. Also, ``Command`` subclasses can now set their ``command_consumes_arguments`` attribute to ``True`` in order to receive an ``args`` option containing the rest of the command line. * Added support for installing scripts * Added support for setting options via distutils configuration files, and using distutils' default options as a basis for EasyInstall's defaults. * Renamed ``--scan-url/-s`` to ``--find-links/-f`` to free up ``-s`` for the script installation directory option. * Use ``urllib2`` instead of ``urllib``, to allow use of ``https:`` URLs if Python includes SSL support. 0.4a1 ===== * Added ``--scan-url`` and ``--index-url`` options, to scan download pages and search PyPI for needed packages. 0.3a4 ===== * Restrict ``--build-directory=DIR/-b DIR`` option to only be used with single URL installs, to avoid running the wrong setup.py. 0.3a3 ===== * Added ``--build-directory=DIR/-b DIR`` option. * Added "installation report" that explains how to use 'require()' when doing a multiversion install or alternate installation directory. * Added SourceForge mirror auto-select (Contributed by Ian Bicking) * Added "sandboxing" that stops a setup script from running if it attempts to write to the filesystem outside of the build area * Added more workarounds for packages with quirky ``install_data`` hacks 0.3a2 ===== * Added new options to ``bdist_egg`` to allow tagging the egg's version number with a subversion revision number, the current date, or an explicit tag value. Run ``setup.py bdist_egg --help`` to get more information. * Added subversion download support for ``svn:`` and ``svn+`` URLs, as well as automatic recognition of HTTP subversion URLs (Contributed by Ian Bicking) * Misc. bug fixes 0.3a1 ===== * Initial release. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5595517 setuptools-68.1.2/PKG-INFO0000644000175100001730000000673614467657444014570 0ustar00runnerdockerMetadata-Version: 2.1 Name: setuptools Version: 68.1.2 Summary: Easily download, build, install, upgrade, and uninstall Python packages Home-page: https://github.com/pypa/setuptools Author: Python Packaging Authority Author-email: distutils-sig@python.org Project-URL: Documentation, https://setuptools.pypa.io/ Project-URL: Changelog, https://setuptools.pypa.io/en/stable/history.html Keywords: CPAN PyPI distutils eggs package management Classifier: Development Status :: 5 - Production/Stable Classifier: Intended Audience :: Developers Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python :: 3 Classifier: Programming Language :: Python :: 3 :: Only Classifier: Topic :: Software Development :: Libraries :: Python Modules Classifier: Topic :: System :: Archiving :: Packaging Classifier: Topic :: System :: Systems Administration Classifier: Topic :: Utilities Requires-Python: >=3.8 Provides-Extra: testing Provides-Extra: testing-integration Provides-Extra: docs Provides-Extra: ssl Provides-Extra: certs License-File: LICENSE .. image:: https://img.shields.io/pypi/v/setuptools.svg :target: https://pypi.org/project/setuptools .. image:: https://img.shields.io/pypi/pyversions/setuptools.svg .. image:: https://github.com/pypa/setuptools/workflows/tests/badge.svg :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22 :alt: tests .. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json :target: https://github.com/astral-sh/ruff :alt: Ruff .. image:: https://img.shields.io/badge/code%20style-black-000000.svg :target: https://github.com/psf/black :alt: Code style: Black .. image:: https://img.shields.io/readthedocs/setuptools/latest.svg :target: https://setuptools.pypa.io .. image:: https://img.shields.io/badge/skeleton-2023-informational :target: https://blog.jaraco.com/skeleton .. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white :target: https://codecov.io/gh/pypa/setuptools .. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme .. image:: https://img.shields.io/discord/803025117553754132 :target: https://discord.com/channels/803025117553754132/815945031150993468 :alt: Discord See the `Installation Instructions `_ in the Python Packaging User's Guide for instructions on installing, upgrading, and uninstalling Setuptools. Questions and comments should be directed to `GitHub Discussions `_. Bug reports and especially tested patches may be submitted directly to the `bug tracker `_. Code of Conduct =============== Everyone interacting in the setuptools project's codebases, issue trackers, chat rooms, and fora is expected to follow the `PSF Code of Conduct `_. For Enterprise ============== Available as part of the Tidelift Subscription. Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. `Learn more `_. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/README.rst0000644000175100001730000000465214467657412015150 0ustar00runnerdocker.. image:: https://img.shields.io/pypi/v/setuptools.svg :target: https://pypi.org/project/setuptools .. image:: https://img.shields.io/pypi/pyversions/setuptools.svg .. image:: https://github.com/pypa/setuptools/workflows/tests/badge.svg :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22 :alt: tests .. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json :target: https://github.com/astral-sh/ruff :alt: Ruff .. image:: https://img.shields.io/badge/code%20style-black-000000.svg :target: https://github.com/psf/black :alt: Code style: Black .. image:: https://img.shields.io/readthedocs/setuptools/latest.svg :target: https://setuptools.pypa.io .. image:: https://img.shields.io/badge/skeleton-2023-informational :target: https://blog.jaraco.com/skeleton .. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white :target: https://codecov.io/gh/pypa/setuptools .. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme .. image:: https://img.shields.io/discord/803025117553754132 :target: https://discord.com/channels/803025117553754132/815945031150993468 :alt: Discord See the `Installation Instructions `_ in the Python Packaging User's Guide for instructions on installing, upgrading, and uninstalling Setuptools. Questions and comments should be directed to `GitHub Discussions `_. Bug reports and especially tested patches may be submitted directly to the `bug tracker `_. Code of Conduct =============== Everyone interacting in the setuptools project's codebases, issue trackers, chat rooms, and fora is expected to follow the `PSF Code of Conduct `_. For Enterprise ============== Available as part of the Tidelift Subscription. Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use. `Learn more `_. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4835474 setuptools-68.1.2/_distutils_hack/0000755000175100001730000000000014467657443016627 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/_distutils_hack/__init__.py0000644000175100001730000001423314467657412020737 0ustar00runnerdocker# don't import any costly modules import sys import os is_pypy = '__pypy__' in sys.builtin_module_names def warn_distutils_present(): if 'distutils' not in sys.modules: return if is_pypy and sys.version_info < (3, 7): # PyPy for 3.6 unconditionally imports distutils, so bypass the warning # https://foss.heptapod.net/pypy/pypy/-/blob/be829135bc0d758997b3566062999ee8b23872b4/lib-python/3/site.py#L250 return import warnings warnings.warn( "Distutils was imported before Setuptools, but importing Setuptools " "also replaces the `distutils` module in `sys.modules`. This may lead " "to undesirable behaviors or errors. To avoid these issues, avoid " "using distutils directly, ensure that setuptools is installed in the " "traditional way (e.g. not an editable install), and/or make sure " "that setuptools is always imported before distutils." ) def clear_distutils(): if 'distutils' not in sys.modules: return import warnings warnings.warn("Setuptools is replacing distutils.") mods = [ name for name in sys.modules if name == "distutils" or name.startswith("distutils.") ] for name in mods: del sys.modules[name] def enabled(): """ Allow selection of distutils by environment variable. """ which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local') return which == 'local' def ensure_local_distutils(): import importlib clear_distutils() # With the DistutilsMetaFinder in place, # perform an import to cause distutils to be # loaded from setuptools._distutils. Ref #2906. with shim(): importlib.import_module('distutils') # check that submodules load as expected core = importlib.import_module('distutils.core') assert '_distutils' in core.__file__, core.__file__ assert 'setuptools._distutils.log' not in sys.modules def do_override(): """ Ensure that the local copy of distutils is preferred over stdlib. See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401 for more motivation. """ if enabled(): warn_distutils_present() ensure_local_distutils() class _TrivialRe: def __init__(self, *patterns): self._patterns = patterns def match(self, string): return all(pat in string for pat in self._patterns) class DistutilsMetaFinder: def find_spec(self, fullname, path, target=None): # optimization: only consider top level modules and those # found in the CPython test suite. if path is not None and not fullname.startswith('test.'): return method_name = 'spec_for_{fullname}'.format(**locals()) method = getattr(self, method_name, lambda: None) return method() def spec_for_distutils(self): if self.is_cpython(): return import importlib import importlib.abc import importlib.util try: mod = importlib.import_module('setuptools._distutils') except Exception: # There are a couple of cases where setuptools._distutils # may not be present: # - An older Setuptools without a local distutils is # taking precedence. Ref #2957. # - Path manipulation during sitecustomize removes # setuptools from the path but only after the hook # has been loaded. Ref #2980. # In either case, fall back to stdlib behavior. return class DistutilsLoader(importlib.abc.Loader): def create_module(self, spec): mod.__name__ = 'distutils' return mod def exec_module(self, module): pass return importlib.util.spec_from_loader( 'distutils', DistutilsLoader(), origin=mod.__file__ ) @staticmethod def is_cpython(): """ Suppress supplying distutils for CPython (build and tests). Ref #2965 and #3007. """ return os.path.isfile('pybuilddir.txt') def spec_for_pip(self): """ Ensure stdlib distutils when running under pip. See pypa/pip#8761 for rationale. """ if sys.version_info >= (3, 12) or self.pip_imported_during_build(): return clear_distutils() self.spec_for_distutils = lambda: None @classmethod def pip_imported_during_build(cls): """ Detect if pip is being imported in a build script. Ref #2355. """ import traceback return any( cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None) ) @staticmethod def frame_file_is_setup(frame): """ Return True if the indicated frame suggests a setup.py file. """ # some frames may not have __file__ (#2940) return frame.f_globals.get('__file__', '').endswith('setup.py') def spec_for_sensitive_tests(self): """ Ensure stdlib distutils when running select tests under CPython. python/cpython#91169 """ clear_distutils() self.spec_for_distutils = lambda: None sensitive_tests = ( [ 'test.test_distutils', 'test.test_peg_generator', 'test.test_importlib', ] if sys.version_info < (3, 10) else [ 'test.test_distutils', ] ) for name in DistutilsMetaFinder.sensitive_tests: setattr( DistutilsMetaFinder, f'spec_for_{name}', DistutilsMetaFinder.spec_for_sensitive_tests, ) DISTUTILS_FINDER = DistutilsMetaFinder() def add_shim(): DISTUTILS_FINDER in sys.meta_path or insert_shim() class shim: def __enter__(self): insert_shim() def __exit__(self, exc, value, tb): _remove_shim() def insert_shim(): sys.meta_path.insert(0, DISTUTILS_FINDER) def _remove_shim(): try: sys.meta_path.remove(DISTUTILS_FINDER) except ValueError: pass if sys.version_info < (3, 12): # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632) remove_shim = _remove_shim ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/_distutils_hack/override.py0000644000175100001730000000005414467657412021013 0ustar00runnerdocker__import__('_distutils_hack').do_override() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/conftest.py0000644000175100001730000000312614467657412015653 0ustar00runnerdockerimport sys import pytest pytest_plugins = 'setuptools.tests.fixtures' def pytest_addoption(parser): parser.addoption( "--package_name", action="append", default=[], help="list of package_name to pass to test functions", ) parser.addoption( "--integration", action="store_true", default=False, help="run integration tests (only)", ) def pytest_configure(config): config.addinivalue_line("markers", "integration: integration tests") config.addinivalue_line("markers", "uses_network: tests may try to download files") collect_ignore = [ 'tests/manual_test.py', 'setuptools/tests/mod_with_constant.py', 'setuptools/_distutils', '_distutils_hack', 'setuptools/extern', 'pkg_resources/extern', 'pkg_resources/tests/data', 'setuptools/_vendor', 'pkg_resources/_vendor', 'setuptools/config/_validate_pyproject', ] if sys.version_info < (3, 6): collect_ignore.append('docs/conf.py') # uses f-strings collect_ignore.append('pavement.py') if sys.version_info < (3, 9) or sys.platform == 'cygwin': collect_ignore.append('tools/finalize.py') @pytest.fixture(autouse=True) def _skip_integration(request): running_integration_tests = request.config.getoption("--integration") is_integration_test = request.node.get_closest_marker("integration") if running_integration_tests and not is_integration_test: pytest.skip("running integration tests only") if not running_integration_tests and is_integration_test: pytest.skip("skipping integration tests") ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4835474 setuptools-68.1.2/docs/0000755000175100001730000000000014467657443014406 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/artwork.rst0000644000175100001730000001110314467657412016621 0ustar00runnerdocker======= Artwork ======= .. figure:: images/logo-over-white.svg :align: center Setuptools logo, designed in 2021 by `Anderson Bravalheri`_ Elements of Design ================== The main colours of the design are a dark pastel azure (``#336790``) and a pale orange (``#E5B62F``), referred in this document simply as "blue" and "yellow" respectively. The text uses the *Monoid* typeface, an open source webfont that was developed by Andreas Larsen and contributors in 2015 and is distributed under the MIT or SIL licenses (more information at https://github.com/larsenwork/monoid) Usage ===== The preferred way of using the setuptools logo is over a white (or light) background. Alternatively, the following options can be considered, depending on the circumstances: - *"negative"* design - for dark backgrounds (e.g. website displayed in "dark mode"): the white colour (``#FFFFFF``) of the background and the "blue" (``#336790``) colour of the design can be swapped. - *"monochrome"* - when colours are not available (e.g. black and white printed media): a completely black or white version of the logo can also be used. - *"banner"* mode: the symbol and text can be used alongside depending on the available space. The following image illustrate these alternatives: .. image:: images/logo-demo.svg :align: center Please refer to the SVG files in the `setuptools repository`_ for the specific shapes and proportions between the elements of the design. Working with the Design ======================= The `setuptools repository`_ contains a series of vector representations of the design under the ``docs/images`` directory. These representations can be manipulated via any graphic editor that support SVG files, however the free and open-source software Inkscape_ is recommended for maximum compatibility. When selecting the right file to work with, file names including ``editable-inkscape`` indicate "more editable" elements (e.g. editable text), while the others prioritise SVG paths for maximum reproducibility. Also notice that you might have to `install the correct fonts`_ to be able to visualise or edit some of the designs. Inspiration =========== This design was inspired by :user:`cajhne`'s `original proposal`_ and the ancient symbol of the ouroboros_. It features a snake moving in a circular trajectory not only as a reference to the Python programming language but also to the :pep:`wheel package format <427>` as one of the distribution formats supported by setuptools. The shape of the snake also resembles a cog, which together with the hammer is a nod to the two words that compose the name of the project. License ======= This logo, design variations or a modified version may be used by anyone to refer to setuptools, but does not indicate endorsement by the project. Redistribution, usage and derivative works are permitted under the same license used by the setuptools software (MIT): .. code-block:: text Copyright (c) Anderson Bravalheri Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. THE USAGE OF THIS LOGO AND ARTWORK DOES NOT INDICATE ENDORSEMENT BY THE SETUPTOOLS PROJECT. Whenever possible, please make the image a link to https://github.com/pypa/setuptools or https://setuptools.pypa.io. .. _Anderson Bravalheri: https://github.com/abravalheri .. _Inkscape: https://inkscape.org .. _setuptools repository: https://github.com/pypa/setuptools .. _install the correct fonts: https://wiki.inkscape.org/wiki/Installing_fonts .. _original proposal: https://github.com/pypa/setuptools/issues/2227#issuecomment-653628344 .. _ouroboros: https://en.wikipedia.org/wiki/Ouroboros ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/build_meta.rst0000644000175100001730000001542214467657412017245 0ustar00runnerdocker======================================= Build System Support ======================================= What is it? ------------- Python packaging has come `a long way `_. The traditional ``setuptools`` way of packaging Python modules uses a ``setup()`` function within the ``setup.py`` script. Commands such as ``python setup.py bdist`` or ``python setup.py bdist_wheel`` generate a distribution bundle and ``python setup.py install`` installs the distribution. This interface makes it difficult to choose other packaging tools without an overhaul. Because ``setup.py`` scripts allow for arbitrary execution, it is difficult to provide a reliable user experience across environments and history. :pep:`517` came to the rescue and specified a new standard for packaging and distributing Python modules. Under PEP 517: A ``pyproject.toml`` file is used to specify which program to use to generate the distribution. Two functions provided by the program, ``build_wheel(directory: str)`` and ``build_sdist(directory: str)``, create the distribution bundle in the specified ``directory``. The program may use its own configuration file or extend the ``.toml`` file. The actual installation is done with ``pip install *.whl`` or ``pip install *.tar.gz``. If ``*.whl`` is available, ``pip`` will go ahead and copy its files into the ``site-packages`` directory. If not, ``pip`` will look at ``pyproject.toml`` and decide which program to use to 'build from source'. (Note that if there is no ``pyproject.toml`` file or the ``build-backend`` parameter is not defined, then the fall-back behaviour is to use ``setuptools``.) With this standard, switching between packaging tools is a lot easier. How to use it? -------------- Start with a package that you want to distribute. You will need your source files, a ``pyproject.toml`` file and a ``setup.cfg`` file:: ~/meowpkg/ pyproject.toml setup.cfg meowpkg/ __init__.py module.py The ``pyproject.toml`` file specifies the build system (i.e. what is being used to package your scripts and install from source). To use it with ``setuptools`` the content would be:: [build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" ``build_meta`` implements ``setuptools``' build system support. The ``setuptools`` package implements the ``build_sdist`` command and the ``wheel`` package implements the ``build_wheel`` command; the latter is a dependency of the former exposed via :pep:`517` hooks. Use ``setuptools``' :ref:`declarative config ` to specify the package information in ``setup.cfg``:: [metadata] name = meowpkg version = 0.0.1 description = a package that meows [options] packages = find: .. _building: Now generate the distribution. To build the package, use `PyPA build `_:: $ pip install -q build $ python -m build And now it's done! The ``.whl`` file and ``.tar.gz`` can then be distributed and installed:: dist/ meowpkg-0.0.1.whl meowpkg-0.0.1.tar.gz $ pip install dist/meowpkg-0.0.1.whl or:: $ pip install dist/meowpkg-0.0.1.tar.gz .. _backend-wrapper: Dynamic build dependencies and other ``build_meta`` tweaks ---------------------------------------------------------- With the changes introduced by :pep:`517` and :pep:`518`, the ``setup_requires`` configuration field was deprecated in ``setup.cfg`` and ``setup.py``, in favour of directly listing build dependencies in the ``requires`` field of the ``build-system`` table of ``pyproject.toml``. This approach has a series of advantages and gives package managers and installers the ability to inspect the build requirements in advance and perform a series of optimisations. However, some package authors might still need to dynamically inspect the final user's machine before deciding these requirements. One way of doing that, as specified by :pep:`517`, is to "tweak" ``setuptools.build_meta`` by using an :pep:`in-tree backend <517#in-tree-build-backends>`. .. tip:: Before implementing an *in-tree* backend, have a look at :pep:`PEP 508 <508#environment-markers>`. Most of the time, dependencies with **environment markers** are enough to differentiate operating systems and platforms. If you put the following configuration in your ``pyproject.toml``: .. code-block:: toml [build-system] requires = ["setuptools"] build-backend = "backend" backend-path = ["_custom_build"] then you can implement a thin wrapper around ``build_meta`` in the ``_custom_build/backend.py`` file, as shown in the following example: .. code-block:: python from setuptools import build_meta as _orig from setuptools.build_meta import * def get_requires_for_build_wheel(config_settings=None): return _orig.get_requires_for_build_wheel(config_settings) + [...] def get_requires_for_build_sdist(config_settings=None): return _orig.get_requires_for_build_sdist(config_settings) + [...] .. note:: You can override any of the functions specified in :pep:`PEP 517 <517#build-backend-interface>`, not only the ones responsible for gathering requirements. It is important to ``import *`` so that the hooks that you choose not to reimplement would be inherited from the setuptools' backend automatically. This will also cover hooks that might be added in the future like the ones that :pep:`660` declares. .. important:: Make sure your backend script is included in the :doc:`source distribution `, otherwise the build will fail. This can be done by using a SCM_/VCS_ plugin (like :pypi:`setuptools-scm` and :pypi:`setuptools-svn`), or by correctly setting up :ref:`MANIFEST.in `. The generated ``.tar.gz`` and ``.whl`` files are compressed archives that can be inspected as follows: On POSIX systems, this can be done with ``tar -tf dist/*.tar.gz`` and ``unzip -l dist/*.whl``. On Windows systems, you can rename the ``.whl`` to ``.zip`` to be able to inspect it from File Explorer. You can also use the above ``tar`` command in a command prompt to inspect the ``.tar.gz`` file. Alternatively, there are GUI programs like `7-zip`_ that handle ``.tar.gz`` and ``.whl`` files. In general, the backend script should be present in the ``.tar.gz`` (so the project can be built from the source) but not in the ``.whl`` (otherwise the backend script would end up being distributed alongside your package). See ":doc:`/userguide/package_discovery`" for more details about package files. .. _SCM: https://en.wikipedia.org/wiki/Software_configuration_management .. _VCS: https://en.wikipedia.org/wiki/Version_control .. _7-zip: https://www.7-zip.org ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/conf.py0000644000175100001730000002144414467657412015706 0ustar00runnerdockerextensions = [ 'sphinx.ext.autodoc', 'jaraco.packaging.sphinx', ] master_doc = "index" html_theme = "furo" # Link dates and other references in the changelog extensions += ['rst.linker'] link_files = { '../NEWS.rst': dict( using=dict( BB='https://bitbucket.org', GH='https://github.com', ), replace=[ dict( pattern=r'(Issue #|\B#)(?P\d+)', url='{package_url}/issues/{issue}', ), dict( pattern=r'(?m:^((?Pv?\d+(\.\d+){1,2}))\n[-=]+\n)', with_scm='{text}\n{rev[timestamp]:%d %b %Y}\n', ), dict( pattern=r'PEP[- ](?P\d+)', url='https://peps.python.org/pep-{pep_number:0>4}/', ), dict( pattern=r'(?\d+)', url='{package_url}/pull/{pull}', ), dict( pattern=r'BB Pull Request ?#(?P\d+)', url='{BB}/pypa/setuptools/pull-request/{bb_pull_request}', ), dict( pattern=r'Distribute #(?P\d+)', url='{BB}/tarek/distribute/issue/{distribute}', ), dict( pattern=r'Buildout #(?P\d+)', url='{GH}/buildout/buildout/issues/{buildout}', ), dict( pattern=r'Old Setuptools #(?P\d+)', url='http://bugs.python.org/setuptools/issue{old_setuptools}', ), dict( pattern=r'Jython #(?P\d+)', url='http://bugs.jython.org/issue{jython}', ), dict( pattern=r'(Python #|bpo-)(?P\d+)', url='http://bugs.python.org/issue{python}', ), dict( pattern=r'Interop #(?P\d+)', url='{GH}/pypa/interoperability-peps/issues/{interop}', ), dict( pattern=r'Pip #(?P\d+)', url='{GH}/pypa/pip/issues/{pip}', ), dict( pattern=r'Packaging #(?P\d+)', url='{GH}/pypa/packaging/issues/{packaging}', ), dict( pattern=r'[Pp]ackaging (?P\d+(\.\d+)+)', url='{GH}/pypa/packaging/blob/{packaging_ver}/CHANGELOG.rst', ), dict( pattern=r'setuptools_svn #(?P\d+)', url='{GH}/jaraco/setuptools_svn/issues/{setuptools_svn}', ), dict( pattern=r'pypa/(?P[\-\.\w]+)#(?P\d+)', url='{GH}/pypa/{issue_repo}/issues/{issue_number}', ), dict( pattern=r'pypa/(?P[\-\.\w]+)@(?P[\da-f]+)', url='{GH}/pypa/{commit_repo}/commit/{commit_number}', ), ], ), } # Be strict about any broken references nitpicky = True # Include Python intersphinx mapping to prevent failures # jaraco/skeleton#51 extensions += ['sphinx.ext.intersphinx'] intersphinx_mapping = { 'python': ('https://docs.python.org/3', None), } # Preserve authored syntax for defaults autodoc_preserve_defaults = True intersphinx_mapping.update( { 'pip': ('https://pip.pypa.io/en/latest', None), 'build': ('https://pypa-build.readthedocs.io/en/latest', None), 'PyPUG': ('https://packaging.python.org/en/latest/', None), 'packaging': ('https://packaging.pypa.io/en/latest/', None), 'twine': ('https://twine.readthedocs.io/en/stable/', None), 'importlib-resources': ( 'https://importlib-resources.readthedocs.io/en/latest', None, ), } ) # Support tooltips on references extensions += ['hoverxref.extension'] hoverxref_auto_ref = True hoverxref_intersphinx = [ 'python', 'pip', 'build', 'PyPUG', 'packaging', 'twine', 'importlib-resources', ] # Add support for linking usernames github_url = 'https://github.com' github_repo_org = 'pypa' github_repo_name = 'setuptools' github_repo_slug = f'{github_repo_org}/{github_repo_name}' github_repo_url = f'{github_url}/{github_repo_slug}' github_sponsors_url = f'{github_url}/sponsors' extlinks = { 'user': (f'{github_sponsors_url}/%s', '@%s'), # noqa: WPS323 'pypi': ('https://pypi.org/project/%s', '%s'), # noqa: WPS323 'wiki': ('https://wikipedia.org/wiki/%s', '%s'), # noqa: WPS323 } extensions += ['sphinx.ext.extlinks'] # Ref: https://github.com/python-attrs/attrs/pull/571/files\ # #diff-85987f48f1258d9ee486e3191495582dR82 default_role = 'any' # HTML theme html_theme = 'furo' html_logo = "images/logo.svg" html_theme_options = { "sidebar_hide_name": True, "light_css_variables": { "color-brand-primary": "#336790", # "blue" "color-brand-content": "#336790", }, "dark_css_variables": { "color-brand-primary": "#E5B62F", # "yellow" "color-brand-content": "#E5B62F", }, } # Redirect old docs so links and references in the ecosystem don't break extensions += ['sphinx_reredirects'] redirects = { "userguide/keywords": "/deprecated/changed_keywords.html", "userguide/commands": "/deprecated/commands.html", } # Add support for inline tabs extensions += ['sphinx_inline_tabs'] # Support for distutils # Ref: https://stackoverflow.com/a/30624034/595220 nitpick_ignore = [ ('c:func', 'SHGetSpecialFolderPath'), # ref to MS docs ('envvar', 'DISTUTILS_DEBUG'), # undocumented ('envvar', 'HOME'), # undocumented ('envvar', 'PLAT'), # undocumented ('envvar', 'DIST_EXTRA_CONFIG'), # undocumented ('py:attr', 'CCompiler.language_map'), # undocumented ('py:attr', 'CCompiler.language_order'), # undocumented ('py:class', 'distutils.dist.Distribution'), # undocumented ('py:class', 'distutils.extension.Extension'), # undocumented ('py:class', 'BorlandCCompiler'), # undocumented ('py:class', 'CCompiler'), # undocumented ('py:class', 'CygwinCCompiler'), # undocumented ('py:class', 'distutils.dist.DistributionMetadata'), # undocumented ('py:class', 'FileList'), # undocumented ('py:class', 'IShellLink'), # ref to MS docs ('py:class', 'MSVCCompiler'), # undocumented ('py:class', 'OptionDummy'), # undocumented ('py:class', 'UnixCCompiler'), # undocumented ('py:exc', 'CompileError'), # undocumented ('py:exc', 'DistutilsExecError'), # undocumented ('py:exc', 'DistutilsFileError'), # undocumented ('py:exc', 'LibError'), # undocumented ('py:exc', 'LinkError'), # undocumented ('py:exc', 'PreprocessError'), # undocumented ('py:exc', 'setuptools.errors.PlatformError'), # sphinx cannot find it ('py:func', 'distutils.CCompiler.new_compiler'), # undocumented # undocumented: ('py:func', 'distutils.dist.DistributionMetadata.read_pkg_file'), ('py:func', 'distutils.file_util._copy_file_contents'), # undocumented ('py:func', 'distutils.log.debug'), # undocumented ('py:func', 'distutils.spawn.find_executable'), # undocumented ('py:func', 'distutils.spawn.spawn'), # undocumented # TODO: check https://docutils.rtfd.io in the future ('py:mod', 'docutils'), # there's no Sphinx site documenting this ] # Allow linking objects on other Sphinx sites seamlessly: intersphinx_mapping.update( python=('https://docs.python.org/3', None), ) # Add support for the unreleased "next-version" change notes extensions += ['sphinxcontrib.towncrier'] # Extension needs a path from here to the towncrier config. towncrier_draft_working_directory = '..' # Avoid an empty section for unpublished changes. towncrier_draft_include_empty = False # sphinx-contrib/sphinxcontrib-towncrier#81 towncrier_draft_config_path = 'towncrier.toml' extensions += ['jaraco.tidelift'] # Add icons (aka "favicons") to documentation extensions += ['sphinx_favicon'] html_static_path = ['images'] # should contain the folder with icons # Add support for nice Not Found 404 pages # extensions += ['notfound.extension'] # readthedocs/sphinx-notfound-page#219 # List of dicts with HTML attributes # static-file points to files in the html_static_path (href is computed) favicons = [ { # "Catch-all" goes first, otherwise some browsers will overwrite "rel": "icon", "type": "image/svg+xml", "static-file": "logo-symbol-only.svg", "sizes": "any", }, { # Version with thicker strokes for better visibility at smaller sizes "rel": "icon", "type": "image/svg+xml", "static-file": "favicon.svg", "sizes": "16x16 24x24 32x32 48x48", }, # rel="apple-touch-icon" does not support SVG yet ] ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4875476 setuptools-68.1.2/docs/deprecated/0000755000175100001730000000000014467657443016506 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/changed_keywords.rst0000644000175100001730000000420114467657412022551 0ustar00runnerdockerNew and Changed ``setup()`` Keywords ==================================== This document tracks historical differences between ``setuptools`` and ``distutils``. Since ``distutils`` was scheduled for removal from the standard library in Python 3.12, and ``setuptools`` started its adoption, these differences became less relevant. Please check :doc:`/references/keywords` for a complete list of keyword arguments that can be passed to the ``setuptools.setup()`` function and a their full description. .. tab:: Supported by both ``distutils`` and ``setuptoools`` ``name`` string ``version`` string ``description`` string ``long_description`` string ``long_description_content_type`` string ``author`` string ``author_email`` string ``maintainer`` string ``maintainer_email`` string ``url`` string ``download_url`` string ``packages`` list ``py_modules`` list ``scripts`` list ``ext_package`` string ``ext_modules`` list ``classifiers`` list ``distclass`` Distribution subclass ``script_name`` string ``script_args`` list ``options`` dictionary ``license`` string ``license_file`` string **deprecated** ``license_files`` list ``keywords`` string or list ``platforms`` list ``cmdclass`` dictionary ``data_files`` list **deprecated** ``package_dir`` dictionary ``requires`` string or list **deprecated** ``obsoletes`` list **deprecated** ``provides`` list .. tab:: Added or changed by ``setuptoools`` ``include_package_data`` bool ``exclude_package_data`` dictionary ``package_data`` dictionary ``zip_safe`` bool ``install_requires`` string or list ``entry_points`` dictionary ``extras_require`` dictionary ``python_requires`` string ``setup_requires`` string or list **deprecated** ``dependency_links`` list **deprecated** ``namespace_packages`` list ``test_suite`` string or function **deprecated** ``tests_require`` string or list **deprecated** ``test_loader`` class **deprecated** ``eager_resources`` list ``project_urls`` dictionary ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/commands.rst0000644000175100001730000007175214467657412021051 0ustar00runnerdocker=============================== Running ``setuptools`` commands =============================== Historically, ``setuptools`` allowed running commands via a ``setup.py`` script at the root of a Python project, as indicated in the examples below:: python setup.py --help python setup.py --help-commands python setup.py --version python setup.py sdist python setup.py bdist_wheel You could also run commands in other circumstances: * ``setuptools`` projects without ``setup.py`` (e.g., ``setup.cfg``-only):: python -c "from setuptools import setup; setup()" --help * ``distutils`` projects (with a ``setup.py`` importing ``distutils``):: python -c "import setuptools; with open('setup.py') as f: exec(compile(f.read(), 'setup.py', 'exec'))" develop That is, you can simply list the normal setup commands and options following the quoted part. .. warning:: While it is perfectly fine that users write ``setup.py`` files to configure a package build (e.g. to specify binary extensions or customize commands), on recent versions of ``setuptools``, running ``python setup.py`` directly as a script is considered **deprecated**. This also means that users should avoid running commands directly via ``python setup.py ``. If you want to create :term:`sdist ` or :term:`wheel` distributions the recommendation is to use the command line tool provided by :pypi:`build`:: pip install build # needs to be installed first python -m build # builds both sdist and wheel python -m build --sdist python -m build --wheel Build will automatically download ``setuptools`` and build the package in an isolated environment. You can also specify specific versions of ``setuptools``, by setting the :doc:`build requirements in pyproject.toml `. If you want to install a package, you can use :pypi:`pip` or :pypi:`installer`:: pip install /path/to/wheel/file.whl pip install /path/to/sdist/file.tar.gz pip install . # replacement for python setup.py install pip install --editable . # replacement for python setup.py develop pip install installer # needs to be installed first python -m installer /path/to/wheel/file.whl ----------------- Command Reference ----------------- .. _alias: ``alias`` - Define shortcuts for commonly used commands ======================================================= Sometimes, you need to use the same commands over and over, but you can't necessarily set them as defaults. For example, if you produce both development snapshot releases and "stable" releases of a project, you may want to put the distributions in different places, or use different ``egg_info`` tagging options, etc. In these cases, it doesn't make sense to set the options in a distutils configuration file, because the values of the options changed based on what you're trying to do. Setuptools therefore allows you to define "aliases" - shortcut names for an arbitrary string of commands and options, using ``setup.py alias aliasname expansion``, where aliasname is the name of the new alias, and the remainder of the command line supplies its expansion. For example, this command defines a sitewide alias called "daily", that sets various ``egg_info`` tagging options:: setup.py alias --global-config daily egg_info --tag-build=development Once the alias is defined, it can then be used with other setup commands, e.g.:: setup.py daily bdist_egg # generate a daily-build .egg file setup.py daily sdist # generate a daily-build source distro setup.py daily sdist bdist_egg # generate both The above commands are interpreted as if the word ``daily`` were replaced with ``egg_info --tag-build=development``. Note that setuptools will expand each alias *at most once* in a given command line. This serves two purposes. First, if you accidentally create an alias loop, it will have no effect; you'll instead get an error message about an unknown command. Second, it allows you to define an alias for a command, that uses that command. For example, this (project-local) alias:: setup.py alias bdist_egg bdist_egg rotate -k1 -m.egg redefines the ``bdist_egg`` command so that it always runs the ``rotate`` command afterwards to delete all but the newest egg file. It doesn't loop indefinitely on ``bdist_egg`` because the alias is only expanded once when used. You can remove a defined alias with the ``--remove`` (or ``-r``) option, e.g.:: setup.py alias --global-config --remove daily would delete the "daily" alias we defined above. Aliases can be defined on a project-specific, per-user, or sitewide basis. The default is to define or remove a project-specific alias, but you can use any of the `configuration file options`_ (listed under the `saveopts`_ command, below) to determine which distutils configuration file an aliases will be added to (or removed from). Note that if you omit the "expansion" argument to the ``alias`` command, you'll get output showing that alias' current definition (and what configuration file it's defined in). If you omit the alias name as well, you'll get a listing of all current aliases along with their configuration file locations. ``bdist_egg`` - Create a Python Egg for the project =================================================== .. warning:: **eggs** are deprecated in favor of wheels, and not supported by pip. This command generates a Python Egg (``.egg`` file) for the project. Python Eggs are the preferred binary distribution format for EasyInstall, because they are cross-platform (for "pure" packages), directly importable, and contain project metadata including scripts and information about the project's dependencies. They can be simply downloaded and added to ``sys.path`` directly, or they can be placed in a directory on ``sys.path`` and then automatically discovered by the egg runtime system. This command runs the `egg_info`_ command (if it hasn't already run) to update the project's metadata (``.egg-info``) directory. If you have added any extra metadata files to the ``.egg-info`` directory, those files will be included in the new egg file's metadata directory, for use by the egg runtime system or by any applications or frameworks that use that metadata. You won't usually need to specify any special options for this command; just use ``bdist_egg`` and you're done. But there are a few options that may be occasionally useful: ``--dist-dir=DIR, -d DIR`` Set the directory where the ``.egg`` file will be placed. If you don't supply this, then the ``--dist-dir`` setting of the ``bdist`` command will be used, which is usually a directory named ``dist`` in the project directory. ``--plat-name=PLATFORM, -p PLATFORM`` Set the platform name string that will be embedded in the egg's filename (assuming the egg contains C extensions). This can be used to override the distutils default platform name with something more meaningful. Keep in mind, however, that the egg runtime system expects to see eggs with distutils platform names, so it may ignore or reject eggs with non-standard platform names. Similarly, the EasyInstall program may ignore them when searching web pages for download links. However, if you are cross-compiling or doing some other unusual things, you might find a use for this option. ``--exclude-source-files`` Don't include any modules' ``.py`` files in the egg, just compiled Python, C, and data files. (Note that this doesn't affect any ``.py`` files in the EGG-INFO directory or its subdirectories, since for example there may be scripts with a ``.py`` extension which must still be retained.) We don't recommend that you use this option except for packages that are being bundled for proprietary end-user applications, or for "embedded" scenarios where space is at an absolute premium. On the other hand, if your package is going to be installed and used in compressed form, you might as well exclude the source because Python's ``traceback`` module doesn't currently understand how to display zipped source code anyway, or how to deal with files that are in a different place from where their code was compiled. There are also some options you will probably never need, but which are there because they were copied from similar ``bdist`` commands used as an example for creating this one. They may be useful for testing and debugging, however, which is why we kept them: ``--keep-temp, -k`` Keep the contents of the ``--bdist-dir`` tree around after creating the ``.egg`` file. ``--bdist-dir=DIR, -b DIR`` Set the temporary directory for creating the distribution. The entire contents of this directory are zipped to create the ``.egg`` file, after running various installation commands to copy the package's modules, data, and extensions here. ``--skip-build`` Skip doing any "build" commands; just go straight to the install-and-compress phases. .. _develop: ``develop`` - Deploy the project source in "Development Mode" ============================================================= This command allows you to deploy your project's source for use in one or more "staging areas" where it will be available for importing. This deployment is done in such a way that changes to the project source are immediately available in the staging area(s), without needing to run a build or install step after each change. The ``develop`` command works by creating an ``.egg-link`` file (named for the project) in the given staging area. If the staging area is Python's ``site-packages`` directory, it also updates an ``easy-install.pth`` file so that the project is on ``sys.path`` by default for all programs run using that Python installation. The ``develop`` command also installs wrapper scripts in the staging area (or a separate directory, as specified) that will ensure the project's dependencies are available on ``sys.path`` before running the project's source scripts. And, it ensures that any missing project dependencies are available in the staging area, by downloading and installing them if necessary. Last, but not least, the ``develop`` command invokes the ``build_ext -i`` command to ensure any C extensions in the project have been built and are up-to-date, and the ``egg_info`` command to ensure the project's metadata is updated (so that the runtime and wrappers know what the project's dependencies are). If you make any changes to the project's setup script or C extensions, you should rerun the ``develop`` command against all relevant staging areas to keep the project's scripts, metadata and extensions up-to-date. Most other kinds of changes to your project should not require any build operations or rerunning ``develop``, but keep in mind that even minor changes to the setup script (e.g. changing an entry point definition) require you to re-run the ``develop`` or ``test`` commands to keep the distribution updated. Here are some of the options that the ``develop`` command accepts. Note that they affect the project's dependencies as well as the project itself, so if you have dependencies that need to be installed and you use ``--exclude-scripts`` (for example), the dependencies' scripts will not be installed either! For this reason, you may want to use pip to install the project's dependencies before using the ``develop`` command, if you need finer control over the installation options for dependencies. ``--uninstall, -u`` Un-deploy the current project. You may use the ``--install-dir`` or ``-d`` option to designate the staging area. The created ``.egg-link`` file will be removed, if present and it is still pointing to the project directory. The project directory will be removed from ``easy-install.pth`` if the staging area is Python's ``site-packages`` directory. Note that this option currently does *not* uninstall script wrappers! You must uninstall them yourself, or overwrite them by using pip to install a different version of the package. You can also avoid installing script wrappers in the first place, if you use the ``--exclude-scripts`` (aka ``-x``) option when you run ``develop`` to deploy the project. ``--multi-version, -m`` "Multi-version" mode. Specifying this option prevents ``develop`` from adding an ``easy-install.pth`` entry for the project(s) being deployed, and if an entry for any version of a project already exists, the entry will be removed upon successful deployment. In multi-version mode, no specific version of the package is available for importing, unless you use ``pkg_resources.require()`` to put it on ``sys.path``, or you are running a wrapper script generated by ``setuptools``. (In which case the wrapper script calls ``require()`` for you.) Note that if you install to a directory other than ``site-packages``, this option is automatically in effect, because ``.pth`` files can only be used in ``site-packages`` (at least in Python 2.3 and 2.4). So, if you use the ``--install-dir`` or ``-d`` option (or they are set via configuration file(s)) your project and its dependencies will be deployed in multi-version mode. ``--install-dir=DIR, -d DIR`` Set the installation directory (staging area). If this option is not directly specified on the command line or in a distutils configuration file, the distutils default installation location is used. Normally, this will be the ``site-packages`` directory, but if you are using distutils configuration files, setting things like ``prefix`` or ``install_lib``, then those settings are taken into account when computing the default staging area. ``--script-dir=DIR, -s DIR`` Set the script installation directory. If you don't supply this option (via the command line or a configuration file), but you *have* supplied an ``--install-dir`` (via command line or config file), then this option defaults to the same directory, so that the scripts will be able to find their associated package installation. Otherwise, this setting defaults to the location where the distutils would normally install scripts, taking any distutils configuration file settings into account. ``--exclude-scripts, -x`` Don't deploy script wrappers. This is useful if you don't want to disturb existing versions of the scripts in the staging area. ``--always-copy, -a`` Copy all needed distributions to the staging area, even if they are already present in another directory on ``sys.path``. By default, if a requirement can be met using a distribution that is already available in a directory on ``sys.path``, it will not be copied to the staging area. ``--egg-path=DIR`` Force the generated ``.egg-link`` file to use a specified relative path to the source directory. This can be useful in circumstances where your installation directory is being shared by code running under multiple platforms (e.g. Mac and Windows) which have different absolute locations for the code under development, but the same *relative* locations with respect to the installation directory. If you use this option when installing, you must supply the same relative path when uninstalling. In addition to the above options, the ``develop`` command also accepts all of the same options accepted by ``easy_install``. If you've configured any ``easy_install`` settings in your ``setup.cfg`` (or other distutils config files), the ``develop`` command will use them as defaults, unless you override them in a ``[develop]`` section or on the command line. .. _egg_info: ``egg_info`` - Create egg metadata and set build tags ===================================================== This command performs two operations: it updates a project's ``.egg-info`` metadata directory (used by the ``bdist_egg``, ``develop``, and ``test`` commands), and it allows you to temporarily change a project's version string, to support "daily builds" or "snapshot" releases. It is run automatically by the ``sdist``, ``bdist_egg``, ``develop``, and ``test`` commands in order to update the project's metadata, but you can also specify it explicitly in order to temporarily change the project's version string while executing other commands. (It also generates the ``.egg-info/SOURCES.txt`` manifest file, which is used when you are building source distributions.) In addition to writing the core egg metadata defined by ``setuptools`` and required by ``pkg_resources``, this command can be extended to write other metadata files as well, by defining entry points in the ``egg_info.writers`` group. See the section on :ref:`Adding new EGG-INFO Files` below for more details. Note that using additional metadata writers may require you to include a ``setup_requires`` argument to ``setup()`` in order to ensure that the desired writers are available on ``sys.path``. Release Tagging Options ----------------------- The following options can be used to modify the project's version string for all remaining commands on the setup command line. The options are processed in the order shown, so if you use more than one, the requested tags will be added in the following order: ``--tag-build=NAME, -b NAME`` Append NAME to the project's version string. Due to the way setuptools processes "pre-release" version suffixes beginning with the letters "a" through "e" (like "alpha", "beta", and "candidate"), you will usually want to use a tag like ".build" or ".dev", as this will cause the version number to be considered *lower* than the project's default version. (If you want to make the version number *higher* than the default version, you can always leave off --tag-build and then use one or both of the following options.) If you have a default build tag set in your ``setup.cfg``, you can suppress it on the command line using ``-b ""`` or ``--tag-build=""`` as an argument to the ``egg_info`` command. ``--tag-date, -d`` Add a date stamp of the form "-YYYYMMDD" (e.g. "-20050528") to the project's version number. ``--no-date, -D`` Don't include a date stamp in the version number. This option is included so you can override a default setting in ``setup.cfg``. (Note: Because these options modify the version number used for source and binary distributions of your project, you should first make sure that you know how the resulting version numbers will be interpreted by automated tools like pip. See the section above on :ref:`Specifying Your Project's Version` for an explanation of pre- and post-release tags, as well as tips on how to choose and verify a versioning scheme for your project.) For advanced uses, there is one other option that can be set, to change the location of the project's ``.egg-info`` directory. Commands that need to find the project's source directory or metadata should get it from this setting: Other ``egg_info`` Options -------------------------- ``--egg-base=SOURCEDIR, -e SOURCEDIR`` Specify the directory that should contain the .egg-info directory. This should normally be the root of your project's source tree (which is not necessarily the same as your project directory; some projects use a ``src`` or ``lib`` subdirectory as the source root). You should not normally need to specify this directory, as it is normally determined from the ``package_dir`` argument to the ``setup()`` function, if any. If there is no ``package_dir`` set, this option defaults to the current directory. ``egg_info`` Examples --------------------- Creating a dated "nightly build" snapshot egg:: setup.py egg_info --tag-date --tag-build=DEV bdist_egg Creating a release with no version tags, even if some default tags are specified in ``setup.cfg``:: setup.py egg_info -RDb "" sdist bdist_egg (Notice that ``egg_info`` must always appear on the command line *before* any commands that you want the version changes to apply to.) .. _rotate: ``rotate`` - Delete outdated distribution files =============================================== As you develop new versions of your project, your distribution (``dist``) directory will gradually fill up with older source and/or binary distribution files. The ``rotate`` command lets you automatically clean these up, keeping only the N most-recently modified files matching a given pattern. ``--match=PATTERNLIST, -m PATTERNLIST`` Comma-separated list of glob patterns to match. This option is *required*. The project name and ``-*`` is prepended to the supplied patterns, in order to match only distributions belonging to the current project (in case you have a shared distribution directory for multiple projects). Typically, you will use a glob pattern like ``.zip`` or ``.egg`` to match files of the specified type. Note that each supplied pattern is treated as a distinct group of files for purposes of selecting files to delete. ``--keep=COUNT, -k COUNT`` Number of matching distributions to keep. For each group of files identified by a pattern specified with the ``--match`` option, delete all but the COUNT most-recently-modified files in that group. This option is *required*. ``--dist-dir=DIR, -d DIR`` Directory where the distributions are. This defaults to the value of the ``bdist`` command's ``--dist-dir`` option, which will usually be the project's ``dist`` subdirectory. **Example 1**: Delete all .tar.gz files from the distribution directory, except for the 3 most recently modified ones:: setup.py rotate --match=.tar.gz --keep=3 **Example 2**: Delete all Python 2.3 or Python 2.4 eggs from the distribution directory, except the most recently modified one for each Python version:: setup.py rotate --match=-py2.3*.egg,-py2.4*.egg --keep=1 .. _saveopts: ``saveopts`` - Save used options to a configuration file ======================================================== Finding and editing ``distutils`` configuration files can be a pain, especially since you also have to translate the configuration options from command-line form to the proper configuration file format. You can avoid these hassles by using the ``saveopts`` command. Just add it to the command line to save the options you used. For example, this command builds the project using the ``mingw32`` C compiler, then saves the --compiler setting as the default for future builds (even those run implicitly by the ``install`` command):: setup.py build --compiler=mingw32 saveopts The ``saveopts`` command saves all options for every command specified on the command line to the project's local ``setup.cfg`` file, unless you use one of the `configuration file options`_ to change where the options are saved. For example, this command does the same as above, but saves the compiler setting to the site-wide (global) distutils configuration:: setup.py build --compiler=mingw32 saveopts -g Note that it doesn't matter where you place the ``saveopts`` command on the command line; it will still save all the options specified for all commands. For example, this is another valid way to spell the last example:: setup.py saveopts -g build --compiler=mingw32 Note, however, that all of the commands specified are always run, regardless of where ``saveopts`` is placed on the command line. Configuration File Options -------------------------- Normally, settings such as options and aliases are saved to the project's local ``setup.cfg`` file. But you can override this and save them to the global or per-user configuration files, or to a manually-specified filename. ``--global-config, -g`` Save settings to the global ``distutils.cfg`` file inside the ``distutils`` package directory. You must have write access to that directory to use this option. You also can't combine this option with ``-u`` or ``-f``. ``--user-config, -u`` Save settings to the current user's ``~/.pydistutils.cfg`` (POSIX) or ``$HOME/pydistutils.cfg`` (Windows) file. You can't combine this option with ``-g`` or ``-f``. ``--filename=FILENAME, -f FILENAME`` Save settings to the specified configuration file to use. You can't combine this option with ``-g`` or ``-u``. Note that if you specify a non-standard filename, the ``distutils`` and ``setuptools`` will not use the file's contents. This option is mainly included for use in testing. These options are used by other ``setuptools`` commands that modify configuration files, such as the `alias`_ and `setopt`_ commands. .. _setopt: ``setopt`` - Set a distutils or setuptools option in a config file ================================================================== This command is mainly for use by scripts, but it can also be used as a quick and dirty way to change a distutils configuration option without having to remember what file the options are in and then open an editor. **Example 1**. Set the default C compiler to ``mingw32`` (using long option names):: setup.py setopt --command=build --option=compiler --set-value=mingw32 **Example 2**. Remove any setting for the distutils default package installation directory (short option names):: setup.py setopt -c install -o install_lib -r Options for the ``setopt`` command: ``--command=COMMAND, -c COMMAND`` Command to set the option for. This option is required. ``--option=OPTION, -o OPTION`` The name of the option to set. This option is required. ``--set-value=VALUE, -s VALUE`` The value to set the option to. Not needed if ``-r`` or ``--remove`` is set. ``--remove, -r`` Remove (unset) the option, instead of setting it. In addition to the above options, you may use any of the `configuration file options`_ (listed under the `saveopts`_ command, above) to determine which distutils configuration file the option will be added to (or removed from). .. _test: ``test`` - Build package and run a unittest suite ================================================= .. warning:: ``test`` is deprecated and will be removed in a future version. Users looking for a generic test entry point independent of test runner are encouraged to use `tox `_. When doing test-driven development, or running automated builds that need testing before they are deployed for downloading or use, it's often useful to be able to run a project's unit tests without actually deploying the project anywhere, even using the ``develop`` command. The ``test`` command runs a project's unit tests without actually deploying it, by temporarily putting the project's source on ``sys.path``, after first running ``build_ext -i`` and ``egg_info`` to ensure that any C extensions and project metadata are up-to-date. To use this command, your project's tests must be wrapped in a ``unittest`` test suite by either a function, a ``TestCase`` class or method, or a module or package containing ``TestCase`` classes. If the named suite is a module, and the module has an ``additional_tests()`` function, it is called and the result (which must be a ``unittest.TestSuite``) is added to the tests to be run. If the named suite is a package, any submodules and subpackages are recursively added to the overall test suite. (Note: if your project specifies a ``test_loader``, the rules for processing the chosen ``test_suite`` may differ; see the :ref:`test_loader ` documentation for more details.) Note that many test systems including ``doctest`` support wrapping their non-``unittest`` tests in ``TestSuite`` objects. So, if you are using a test package that does not support this, we suggest you encourage its developers to implement test suite support, as this is a convenient and standard way to aggregate a collection of tests to be run under a common test harness. By default, tests will be run in the "verbose" mode of the ``unittest`` package's text test runner, but you can get the "quiet" mode (just dots) if you supply the ``-q`` or ``--quiet`` option, either as a global option to the setup script (e.g. ``setup.py -q test``) or as an option for the ``test`` command itself (e.g. ``setup.py test -q``). There is one other option available: ``--test-suite=NAME, -s NAME`` Specify the test suite (or module, class, or method) to be run (e.g. ``some_module.test_suite``). The default for this option can be set by giving a ``test_suite`` argument to the ``setup()`` function, e.g.:: setup( # ... test_suite="my_package.tests.test_all" ) If you did not set a ``test_suite`` in your ``setup()`` call, and do not provide a ``--test-suite`` option, an error will occur. New in 41.5.0: Deprecated the test command. .. _upload: ``upload`` - Upload source and/or egg distributions to PyPI =========================================================== The ``upload`` command was deprecated in version 40.0 and removed in version 42.0. Use `twine `_ instead. For more information on the current best practices in uploading your packages to PyPI, see the Python Packaging User Guide's "Packaging Python Projects" tutorial specifically the section on `uploading the distribution archives `_. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/dependency_links.rst0000644000175100001730000000545314467657412022561 0ustar00runnerdockerSpecifying dependencies that aren't in PyPI via ``dependency_links`` ==================================================================== .. warning:: Dependency links support has been dropped by pip starting with version 19.0 (released 2019-01-22). If your project depends on packages that don't exist on PyPI, you *may* still be able to depend on them if they are available for download as: - an egg, in the standard distutils ``sdist`` format, - a single ``.py`` file, or - a VCS repository (Subversion, Mercurial, or Git). You need to add some URLs to the ``dependency_links`` argument to ``setup()``. The URLs must be either: 1. direct download URLs, 2. the URLs of web pages that contain direct download links, or 3. the repository's URL In general, it's better to link to web pages, because it is usually less complex to update a web page than to release a new version of your project. You can also use a SourceForge ``showfiles.php`` link in the case where a package you depend on is distributed via SourceForge. If you depend on a package that's distributed as a single ``.py`` file, you must include an ``"#egg=project-version"`` suffix to the URL, to give a project name and version number. (Be sure to escape any dashes in the name or version by replacing them with underscores.) EasyInstall will recognize this suffix and automatically create a trivial ``setup.py`` to wrap the single ``.py`` file as an egg. In the case of a VCS checkout, you should also append ``#egg=project-version`` in order to identify for what package that checkout should be used. You can append ``@REV`` to the URL's path (before the fragment) to specify a revision. Additionally, you can also force the VCS being used by prepending the URL with a certain prefix. Currently available are: - ``svn+URL`` for Subversion, - ``git+URL`` for Git, and - ``hg+URL`` for Mercurial A more complete example would be: ``vcs+proto://host/path@revision#egg=project-version`` Be careful with the version. It should match the one inside the project files. If you want to disregard the version, you have to omit it both in the ``requires`` and in the URL's fragment. This will do a checkout (or a clone, in Git and Mercurial parlance) to a temporary folder and run ``setup.py bdist_egg``. The ``dependency_links`` option takes the form of a list of URL strings. For example, this will cause a search of the specified page for eggs or source distributions, if the package's dependencies aren't already installed: .. tab:: setup.cfg .. code-block:: ini [options] #... dependency_links = http://peak.telecommunity.com/snapshots/ .. tab:: setup.py .. code-block:: python setup( ..., dependency_links=[ "http://peak.telecommunity.com/snapshots/", ], ) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4875476 setuptools-68.1.2/docs/deprecated/distutils/0000755000175100001730000000000014467657443020532 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/_setuptools_disclaimer.rst0000644000175100001730000000035014467657412026032 0ustar00runnerdocker.. note:: This document is being retained solely until the ``setuptools`` documentation at https://setuptools.pypa.io/en/latest/setuptools.html independently covers all of the relevant information currently included here. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/apiref.rst0000644000175100001730000027304414467657412022540 0ustar00runnerdocker.. _api-reference: ************* API Reference ************* .. seealso:: `New and changed setup.py arguments in setuptools`_ The ``setuptools`` project adds new capabilities to the ``setup`` function and other APIs, makes the API consistent across different Python versions, and is hence recommended over using ``distutils`` directly. .. _New and changed setup.py arguments in setuptools: https://setuptools.pypa.io/en/latest/setuptools.html#new-and-changed-setup-keywords .. include:: ./_setuptools_disclaimer.rst :mod:`distutils.core` --- Core Distutils functionality ====================================================== .. module:: distutils.core :synopsis: The core Distutils functionality The :mod:`distutils.core` module is the only module that needs to be installed to use the Distutils. It provides the :func:`setup` (which is called from the setup script). Indirectly provides the :class:`distutils.dist.Distribution` and :class:`distutils.cmd.Command` class. .. function:: setup(arguments) The basic do-everything function that does most everything you could ever ask for from a Distutils method. The setup function takes a large number of arguments. These are laid out in the following table. .. tabularcolumns:: |l|L|L| +--------------------+--------------------------------+-------------------------------------------------------------+ | argument name | value | type | +====================+================================+=============================================================+ | *name* | The name of the package | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *version* | The version number of the | a string | | | package; see | | | | :mod:`distutils.version` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *description* | A single line describing the | a string | | | package | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *long_description* | Longer description of the | a string | | | package | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *author* | The name of the package author | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *author_email* | The email address of the | a string | | | package author | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *maintainer* | The name of the current | a string | | | maintainer, if different from | | | | the author. Note that if | | | | the maintainer is provided, | | | | distutils will use it as the | | | | author in :file:`PKG-INFO` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *maintainer_email* | The email address of the | a string | | | current maintainer, if | | | | different from the author | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *url* | A URL for the package | a string | | | (homepage) | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *download_url* | A URL to download the package | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *packages* | A list of Python packages that | a list of strings | | | distutils will manipulate | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *py_modules* | A list of Python modules that | a list of strings | | | distutils will manipulate | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *scripts* | A list of standalone script | a list of strings | | | files to be built and | | | | installed | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *ext_modules* | A list of Python extensions to | a list of instances of | | | be built | :class:`distutils.core.Extension` | +--------------------+--------------------------------+-------------------------------------------------------------+ | *classifiers* | A list of categories for the | a list of strings; valid classifiers are listed on `PyPI | | | package | `_. | +--------------------+--------------------------------+-------------------------------------------------------------+ | *distclass* | the :class:`Distribution` | a subclass of | | | class to use | :class:`distutils.core.Distribution` | +--------------------+--------------------------------+-------------------------------------------------------------+ | *script_name* | The name of the setup.py | a string | | | script - defaults to | | | | ``sys.argv[0]`` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *script_args* | Arguments to supply to the | a list of strings | | | setup script | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *options* | default options for the setup | a dictionary | | | script | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *license* | The license for the package | a string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *keywords* | Descriptive meta-data, see | a list of strings or a comma-separated string | | | :pep:`314` | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *platforms* | | a list of strings or a comma-separated string | +--------------------+--------------------------------+-------------------------------------------------------------+ | *cmdclass* | A mapping of command names to | a dictionary | | | :class:`Command` subclasses | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *data_files* | A list of data files to | a list | | | install | | +--------------------+--------------------------------+-------------------------------------------------------------+ | *package_dir* | A mapping of package to | a dictionary | | | directory names | | +--------------------+--------------------------------+-------------------------------------------------------------+ .. function:: run_setup(script_name[, script_args=None, stop_after='run']) Run a setup script in a somewhat controlled environment, and return the :class:`distutils.dist.Distribution` instance that drives things. This is useful if you need to find out the distribution meta-data (passed as keyword args from *script* to :func:`setup`), or the contents of the config files or command-line. *script_name* is a file that will be read and run with :func:`exec`. ``sys.argv[0]`` will be replaced with *script* for the duration of the call. *script_args* is a list of strings; if supplied, ``sys.argv[1:]`` will be replaced by *script_args* for the duration of the call. *stop_after* tells :func:`setup` when to stop processing; possible values: .. tabularcolumns:: |l|L| +---------------+---------------------------------------------+ | value | description | +===============+=============================================+ | *init* | Stop after the :class:`Distribution` | | | instance has been created and populated | | | with the keyword arguments to :func:`setup` | +---------------+---------------------------------------------+ | *config* | Stop after config files have been parsed | | | (and their data stored in the | | | :class:`Distribution` instance) | +---------------+---------------------------------------------+ | *commandline* | Stop after the command-line | | | (``sys.argv[1:]`` or *script_args*) have | | | been parsed (and the data stored in the | | | :class:`Distribution` instance.) | +---------------+---------------------------------------------+ | *run* | Stop after all commands have been run (the | | | same as if :func:`setup` had been called | | | in the usual way). This is the default | | | value. | +---------------+---------------------------------------------+ In addition, the :mod:`distutils.core` module exposed a number of classes that live elsewhere. * :class:`~distutils.extension.Extension` from :mod:`distutils.extension` * :class:`~distutils.cmd.Command` from :mod:`distutils.cmd` * :class:`~distutils.dist.Distribution` from :mod:`distutils.dist` A short description of each of these follows, but see the relevant module for the full reference. .. class:: Extension The Extension class describes a single C or C++ extension module in a setup script. It accepts the following keyword arguments in its constructor: .. tabularcolumns:: |l|L|l| +------------------------+--------------------------------+---------------------------+ | argument name | value | type | +========================+================================+===========================+ | *name* | the full name of the | a string | | | extension, including any | | | | packages --- ie. *not* a | | | | filename or pathname, but | | | | Python dotted name | | +------------------------+--------------------------------+---------------------------+ | *sources* | list of source filenames, | a list of strings | | | relative to the distribution | | | | root (where the setup script | | | | lives), in Unix form | | | | (slash-separated) for | | | | portability. | | | | Source files may be C, C++, | | | | SWIG (.i), platform-specific | | | | resource files, or whatever | | | | else is recognized by the | | | | :command:`build_ext` command | | | | as source for a Python | | | | extension. | | +------------------------+--------------------------------+---------------------------+ | *include_dirs* | list of directories to search | a list of strings | | | for C/C++ header files (in | | | | Unix form for portability) | | +------------------------+--------------------------------+---------------------------+ | *define_macros* | list of macros to define; each | a list of tuples | | | macro is defined using a | | | | 2-tuple ``(name, value)``, | | | | where *value* is | | | | either the string to define it | | | | to or ``None`` to define it | | | | without a particular value | | | | (equivalent of ``#define FOO`` | | | | in source or :option:`!-DFOO` | | | | on Unix C compiler command | | | | line) | | +------------------------+--------------------------------+---------------------------+ | *undef_macros* | list of macros to undefine | a list of strings | | | explicitly | | +------------------------+--------------------------------+---------------------------+ | *library_dirs* | list of directories to search | a list of strings | | | for C/C++ libraries at link | | | | time | | +------------------------+--------------------------------+---------------------------+ | *libraries* | list of library names (not | a list of strings | | | filenames or paths) to link | | | | against | | +------------------------+--------------------------------+---------------------------+ | *runtime_library_dirs* | list of directories to search | a list of strings | | | for C/C++ libraries at run | | | | time (for shared extensions, | | | | this is when the extension is | | | | loaded) | | +------------------------+--------------------------------+---------------------------+ | *extra_objects* | list of extra files to link | a list of strings | | | with (eg. object files not | | | | implied by 'sources', static | | | | library that must be | | | | explicitly specified, binary | | | | resource files, etc.) | | +------------------------+--------------------------------+---------------------------+ | *extra_compile_args* | any extra platform- and | a list of strings | | | compiler-specific information | | | | to use when compiling the | | | | source files in 'sources'. For | | | | platforms and compilers where | | | | a command line makes sense, | | | | this is typically a list of | | | | command-line arguments, but | | | | for other platforms it could | | | | be anything. | | +------------------------+--------------------------------+---------------------------+ | *extra_link_args* | any extra platform- and | a list of strings | | | compiler-specific information | | | | to use when linking object | | | | files together to create the | | | | extension (or to create a new | | | | static Python interpreter). | | | | Similar interpretation as for | | | | 'extra_compile_args'. | | +------------------------+--------------------------------+---------------------------+ | *export_symbols* | list of symbols to be exported | a list of strings | | | from a shared extension. Not | | | | used on all platforms, and not | | | | generally necessary for Python | | | | extensions, which typically | | | | export exactly one symbol: | | | | ``init`` + extension_name. | | +------------------------+--------------------------------+---------------------------+ | *depends* | list of files that the | a list of strings | | | extension depends on | | +------------------------+--------------------------------+---------------------------+ | *language* | extension language (i.e. | a string | | | ``'c'``, ``'c++'``, | | | | ``'objc'``). Will be detected | | | | from the source extensions if | | | | not provided. | | +------------------------+--------------------------------+---------------------------+ | *optional* | specifies that a build failure | a boolean | | | in the extension should not | | | | abort the build process, but | | | | simply skip the extension. | | +------------------------+--------------------------------+---------------------------+ .. versionchanged:: 3.8 On Unix, C extensions are no longer linked to libpython except on Android and Cygwin. .. class:: Distribution A :class:`Distribution` describes how to build, install and package up a Python software package. See the :func:`setup` function for a list of keyword arguments accepted by the Distribution constructor. :func:`setup` creates a Distribution instance. .. versionchanged:: 3.7 :class:`~distutils.core.Distribution` now warns if ``classifiers``, ``keywords`` and ``platforms`` fields are not specified as a list or a string. .. class:: Command A :class:`Command` class (or rather, an instance of one of its subclasses) implement a single distutils command. :mod:`distutils.ccompiler` --- CCompiler base class =================================================== .. module:: distutils.ccompiler :synopsis: Abstract CCompiler class This module provides the abstract base class for the :class:`CCompiler` classes. A :class:`CCompiler` instance can be used for all the compile and link steps needed to build a single project. Methods are provided to set options for the compiler --- macro definitions, include directories, link path, libraries and the like. This module provides the following functions. .. function:: gen_lib_options(compiler, library_dirs, runtime_library_dirs, libraries) Generate linker options for searching library directories and linking with specific libraries. *libraries* and *library_dirs* are, respectively, lists of library names (not filenames!) and search directories. Returns a list of command-line options suitable for use with some compiler (depending on the two format strings passed in). .. function:: gen_preprocess_options(macros, include_dirs) Generate C pre-processor options (:option:`!-D`, :option:`!-U`, :option:`!-I`) as used by at least two types of compilers: the typical Unix compiler and Visual C++. *macros* is the usual thing, a list of 1- or 2-tuples, where ``(name,)`` means undefine (:option:`!-U`) macro *name*, and ``(name, value)`` means define (:option:`!-D`) macro *name* to *value*. *include_dirs* is just a list of directory names to be added to the header file search path (:option:`!-I`). Returns a list of command-line options suitable for either Unix compilers or Visual C++. .. function:: get_default_compiler(osname, platform) Determine the default compiler to use for the given platform. *osname* should be one of the standard Python OS names (i.e. the ones returned by ``os.name``) and *platform* the common value returned by ``sys.platform`` for the platform in question. The default values are ``os.name`` and ``sys.platform`` in case the parameters are not given. .. function:: new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0) Factory function to generate an instance of some CCompiler subclass for the supplied platform/compiler combination. *plat* defaults to ``os.name`` (eg. ``'posix'``, ``'nt'``), and *compiler* defaults to the default compiler for that platform. Currently only ``'posix'`` and ``'nt'`` are supported, and the default compilers are "traditional Unix interface" (:class:`UnixCCompiler` class) and Visual C++ (:class:`MSVCCompiler` class). Note that it's perfectly possible to ask for a Unix compiler object under Windows, and a Microsoft compiler object under Unix---if you supply a value for *compiler*, *plat* is ignored. .. % Is the posix/nt only thing still true? Mac OS X seems to work, and .. % returns a UnixCCompiler instance. How to document this... hmm. .. function:: show_compilers() Print list of available compilers (used by the :option:`!--help-compiler` options to :command:`build`, :command:`build_ext`, :command:`build_clib`). .. class:: CCompiler([verbose=0, dry_run=0, force=0]) The abstract base class :class:`CCompiler` defines the interface that must be implemented by real compiler classes. The class also has some utility methods used by several compiler classes. The basic idea behind a compiler abstraction class is that each instance can be used for all the compile/link steps in building a single project. Thus, attributes common to all of those compile and link steps --- include directories, macros to define, libraries to link against, etc. --- are attributes of the compiler instance. To allow for variability in how individual files are treated, most of those attributes may be varied on a per-compilation or per-link basis. The constructor for each subclass creates an instance of the Compiler object. Flags are *verbose* (show verbose output), *dry_run* (don't actually execute the steps) and *force* (rebuild everything, regardless of dependencies). All of these flags default to ``0`` (off). Note that you probably don't want to instantiate :class:`CCompiler` or one of its subclasses directly - use the :func:`distutils.CCompiler.new_compiler` factory function instead. The following methods allow you to manually alter compiler options for the instance of the Compiler class. .. method:: CCompiler.add_include_dir(dir) Add *dir* to the list of directories that will be searched for header files. The compiler is instructed to search directories in the order in which they are supplied by successive calls to :meth:`add_include_dir`. .. method:: CCompiler.set_include_dirs(dirs) Set the list of directories that will be searched to *dirs* (a list of strings). Overrides any preceding calls to :meth:`add_include_dir`; subsequent calls to :meth:`add_include_dir` add to the list passed to :meth:`set_include_dirs`. This does not affect any list of standard include directories that the compiler may search by default. .. method:: CCompiler.add_library(libname) Add *libname* to the list of libraries that will be included in all links driven by this compiler object. Note that *libname* should \*not\* be the name of a file containing a library, but the name of the library itself: the actual filename will be inferred by the linker, the compiler, or the compiler class (depending on the platform). The linker will be instructed to link against libraries in the order they were supplied to :meth:`add_library` and/or :meth:`set_libraries`. It is perfectly valid to duplicate library names; the linker will be instructed to link against libraries as many times as they are mentioned. .. method:: CCompiler.set_libraries(libnames) Set the list of libraries to be included in all links driven by this compiler object to *libnames* (a list of strings). This does not affect any standard system libraries that the linker may include by default. .. method:: CCompiler.add_library_dir(dir) Add *dir* to the list of directories that will be searched for libraries specified to :meth:`add_library` and :meth:`set_libraries`. The linker will be instructed to search for libraries in the order they are supplied to :meth:`add_library_dir` and/or :meth:`set_library_dirs`. .. method:: CCompiler.set_library_dirs(dirs) Set the list of library search directories to *dirs* (a list of strings). This does not affect any standard library search path that the linker may search by default. .. method:: CCompiler.add_runtime_library_dir(dir) Add *dir* to the list of directories that will be searched for shared libraries at runtime. .. method:: CCompiler.set_runtime_library_dirs(dirs) Set the list of directories to search for shared libraries at runtime to *dirs* (a list of strings). This does not affect any standard search path that the runtime linker may search by default. .. method:: CCompiler.define_macro(name[, value=None]) Define a preprocessor macro for all compilations driven by this compiler object. The optional parameter *value* should be a string; if it is not supplied, then the macro will be defined without an explicit value and the exact outcome depends on the compiler used. .. XXX true? does ANSI say anything about this? .. method:: CCompiler.undefine_macro(name) Undefine a preprocessor macro for all compilations driven by this compiler object. If the same macro is defined by :meth:`define_macro` and undefined by :meth:`undefine_macro` the last call takes precedence (including multiple redefinitions or undefinitions). If the macro is redefined/undefined on a per-compilation basis (ie. in the call to :meth:`compile`), then that takes precedence. .. method:: CCompiler.add_link_object(object) Add *object* to the list of object files (or analogues, such as explicitly named library files or the output of "resource compilers") to be included in every link driven by this compiler object. .. method:: CCompiler.set_link_objects(objects) Set the list of object files (or analogues) to be included in every link to *objects*. This does not affect any standard object files that the linker may include by default (such as system libraries). The following methods implement methods for autodetection of compiler options, providing some functionality similar to GNU :program:`autoconf`. .. method:: CCompiler.detect_language(sources) Detect the language of a given file, or list of files. Uses the instance attributes :attr:`~CCompiler.language_map` (a dictionary), and :attr:`~CCompiler.language_order` (a list) to do the job. .. method:: CCompiler.find_library_file(dirs, lib[, debug=0]) Search the specified list of directories for a static or shared library file *lib* and return the full path to that file. If *debug* is true, look for a debugging version (if that makes sense on the current platform). Return ``None`` if *lib* wasn't found in any of the specified directories. .. method:: CCompiler.has_function(funcname [, includes=None, include_dirs=None, libraries=None, library_dirs=None]) Return a boolean indicating whether *funcname* is supported on the current platform. The optional arguments can be used to augment the compilation environment by providing additional include files and paths and libraries and paths. .. method:: CCompiler.library_dir_option(dir) Return the compiler option to add *dir* to the list of directories searched for libraries. .. method:: CCompiler.library_option(lib) Return the compiler option to add *lib* to the list of libraries linked into the shared library or executable. .. method:: CCompiler.runtime_library_dir_option(dir) Return the compiler option to add *dir* to the list of directories searched for runtime libraries. .. method:: CCompiler.set_executables(**args) Define the executables (and options for them) that will be run to perform the various stages of compilation. The exact set of executables that may be specified here depends on the compiler class (via the 'executables' class attribute), but most will have: +--------------+------------------------------------------+ | attribute | description | +==============+==========================================+ | *compiler* | the C/C++ compiler | +--------------+------------------------------------------+ | *linker_so* | linker used to create shared objects and | | | libraries | +--------------+------------------------------------------+ | *linker_exe* | linker used to create binary executables | +--------------+------------------------------------------+ | *archiver* | static library creator | +--------------+------------------------------------------+ On platforms with a command-line (Unix, DOS/Windows), each of these is a string that will be split into executable name and (optional) list of arguments. (Splitting the string is done similarly to how Unix shells operate: words are delimited by spaces, but quotes and backslashes can override this. See :func:`distutils.util.split_quoted`.) The following methods invoke stages in the build process. .. method:: CCompiler.compile(sources[, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, depends=None]) Compile one or more source files. Generates object files (e.g. transforms a :file:`.c` file to a :file:`.o` file.) *sources* must be a list of filenames, most likely C/C++ files, but in reality anything that can be handled by a particular compiler and compiler class (eg. :class:`MSVCCompiler` can handle resource files in *sources*). Return a list of object filenames, one per source filename in *sources*. Depending on the implementation, not all source files will necessarily be compiled, but all corresponding object filenames will be returned. If *output_dir* is given, object files will be put under it, while retaining their original path component. That is, :file:`foo/bar.c` normally compiles to :file:`foo/bar.o` (for a Unix implementation); if *output_dir* is *build*, then it would compile to :file:`build/foo/bar.o`. *macros*, if given, must be a list of macro definitions. A macro definition is either a ``(name, value)`` 2-tuple or a ``(name,)`` 1-tuple. The former defines a macro; if the value is ``None``, the macro is defined without an explicit value. The 1-tuple case undefines a macro. Later definitions/redefinitions/undefinitions take precedence. *include_dirs*, if given, must be a list of strings, the directories to add to the default include file search path for this compilation only. *debug* is a boolean; if true, the compiler will be instructed to output debug symbols in (or alongside) the object file(s). *extra_preargs* and *extra_postargs* are implementation-dependent. On platforms that have the notion of a command-line (e.g. Unix, DOS/Windows), they are most likely lists of strings: extra command-line arguments to prepend/append to the compiler command line. On other platforms, consult the implementation class documentation. In any event, they are intended as an escape hatch for those occasions when the abstract compiler framework doesn't cut the mustard. *depends*, if given, is a list of filenames that all targets depend on. If a source file is older than any file in depends, then the source file will be recompiled. This supports dependency tracking, but only at a coarse granularity. Raises :exc:`CompileError` on failure. .. method:: CCompiler.create_static_lib(objects, output_libname[, output_dir=None, debug=0, target_lang=None]) Link a bunch of stuff together to create a static library file. The "bunch of stuff" consists of the list of object files supplied as *objects*, the extra object files supplied to :meth:`add_link_object` and/or :meth:`set_link_objects`, the libraries supplied to :meth:`add_library` and/or :meth:`set_libraries`, and the libraries supplied as *libraries* (if any). *output_libname* should be a library name, not a filename; the filename will be inferred from the library name. *output_dir* is the directory where the library file will be put. .. XXX defaults to what? *debug* is a boolean; if true, debugging information will be included in the library (note that on most platforms, it is the compile step where this matters: the *debug* flag is included here just for consistency). *target_lang* is the target language for which the given objects are being compiled. This allows specific linkage time treatment of certain languages. Raises :exc:`LibError` on failure. .. method:: CCompiler.link(target_desc, objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None]) Link a bunch of stuff together to create an executable or shared library file. The "bunch of stuff" consists of the list of object files supplied as *objects*. *output_filename* should be a filename. If *output_dir* is supplied, *output_filename* is relative to it (i.e. *output_filename* can provide directory components if needed). *libraries* is a list of libraries to link against. These are library names, not filenames, since they're translated into filenames in a platform-specific way (eg. *foo* becomes :file:`libfoo.a` on Unix and :file:`foo.lib` on DOS/Windows). However, they can include a directory component, which means the linker will look in that specific directory rather than searching all the normal locations. *library_dirs*, if supplied, should be a list of directories to search for libraries that were specified as bare library names (ie. no directory component). These are on top of the system default and those supplied to :meth:`add_library_dir` and/or :meth:`set_library_dirs`. *runtime_library_dirs* is a list of directories that will be embedded into the shared library and used to search for other shared libraries that \*it\* depends on at run-time. (This may only be relevant on Unix.) *export_symbols* is a list of symbols that the shared library will export. (This appears to be relevant only on Windows.) *debug* is as for :meth:`compile` and :meth:`create_static_lib`, with the slight distinction that it actually matters on most platforms (as opposed to :meth:`create_static_lib`, which includes a *debug* flag mostly for form's sake). *extra_preargs* and *extra_postargs* are as for :meth:`compile` (except of course that they supply command-line arguments for the particular linker being used). *target_lang* is the target language for which the given objects are being compiled. This allows specific linkage time treatment of certain languages. Raises :exc:`LinkError` on failure. .. method:: CCompiler.link_executable(objects, output_progname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, target_lang=None]) Link an executable. *output_progname* is the name of the file executable, while *objects* are a list of object filenames to link in. Other arguments are as for the :meth:`link` method. .. method:: CCompiler.link_shared_lib(objects, output_libname[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None]) Link a shared library. *output_libname* is the name of the output library, while *objects* is a list of object filenames to link in. Other arguments are as for the :meth:`link` method. .. method:: CCompiler.link_shared_object(objects, output_filename[, output_dir=None, libraries=None, library_dirs=None, runtime_library_dirs=None, export_symbols=None, debug=0, extra_preargs=None, extra_postargs=None, build_temp=None, target_lang=None]) Link a shared object. *output_filename* is the name of the shared object that will be created, while *objects* is a list of object filenames to link in. Other arguments are as for the :meth:`link` method. .. method:: CCompiler.preprocess(source[, output_file=None, macros=None, include_dirs=None, extra_preargs=None, extra_postargs=None]) Preprocess a single C/C++ source file, named in *source*. Output will be written to file named *output_file*, or *stdout* if *output_file* not supplied. *macros* is a list of macro definitions as for :meth:`compile`, which will augment the macros set with :meth:`define_macro` and :meth:`undefine_macro`. *include_dirs* is a list of directory names that will be added to the default list, in the same way as :meth:`add_include_dir`. Raises :exc:`PreprocessError` on failure. The following utility methods are defined by the :class:`CCompiler` class, for use by the various concrete subclasses. .. method:: CCompiler.executable_filename(basename[, strip_dir=0, output_dir='']) Returns the filename of the executable for the given *basename*. Typically for non-Windows platforms this is the same as the basename, while Windows will get a :file:`.exe` added. .. method:: CCompiler.library_filename(libname[, lib_type='static', strip_dir=0, output_dir='']) Returns the filename for the given library name on the current platform. On Unix a library with *lib_type* of ``'static'`` will typically be of the form :file:`liblibname.a`, while a *lib_type* of ``'dynamic'`` will be of the form :file:`liblibname.so`. .. method:: CCompiler.object_filenames(source_filenames[, strip_dir=0, output_dir='']) Returns the name of the object files for the given source files. *source_filenames* should be a list of filenames. .. method:: CCompiler.shared_object_filename(basename[, strip_dir=0, output_dir='']) Returns the name of a shared object file for the given file name *basename*. .. method:: CCompiler.execute(func, args[, msg=None, level=1]) Invokes :func:`distutils.util.execute`. This method invokes a Python function *func* with the given arguments *args*, after logging and taking into account the *dry_run* flag. .. method:: CCompiler.spawn(cmd) Invokes :func:`distutils.spawn.spawn`. This invokes an external process to run the given command. .. method:: CCompiler.mkpath(name[, mode=511]) Invokes :func:`distutils.dir_util.mkpath`. This creates a directory and any missing ancestor directories. .. method:: CCompiler.move_file(src, dst) Invokes :meth:`distutils.file_util.move_file`. Renames *src* to *dst*. .. method:: CCompiler.announce(msg[, level=1]) Write a message using :func:`distutils.log.debug`. .. method:: CCompiler.warn(msg) Write a warning message *msg* to standard error. .. method:: CCompiler.debug_print(msg) If the *debug* flag is set on this :class:`CCompiler` instance, print *msg* to standard output, otherwise do nothing. .. % \subsection{Compiler-specific modules} .. % .. % The following modules implement concrete subclasses of the abstract .. % \class{CCompiler} class. They should not be instantiated directly, but should .. % be created using \function{distutils.ccompiler.new_compiler()} factory .. % function. :mod:`distutils.unixccompiler` --- Unix C Compiler ================================================== .. module:: distutils.unixccompiler :synopsis: UNIX C Compiler This module provides the :class:`UnixCCompiler` class, a subclass of :class:`CCompiler` that handles the typical Unix-style command-line C compiler: * macros defined with :option:`!-Dname[=value]` * macros undefined with :option:`!-Uname` * include search directories specified with :option:`!-Idir` * libraries specified with :option:`!-llib` * library search directories specified with :option:`!-Ldir` * compile handled by :program:`cc` (or similar) executable with :option:`!-c` option: compiles :file:`.c` to :file:`.o` * link static library handled by :program:`ar` command (possibly with :program:`ranlib`) * link shared library handled by :program:`cc` :option:`!-shared` :mod:`distutils.msvccompiler` --- Microsoft Compiler ==================================================== .. module:: distutils.msvccompiler :synopsis: Microsoft Compiler .. XXX: This is *waaaaay* out of date! This module provides :class:`MSVCCompiler`, an implementation of the abstract :class:`CCompiler` class for Microsoft Visual Studio. Typically, extension modules need to be compiled with the same compiler that was used to compile Python. For Python 2.3 and earlier, the compiler was Visual Studio 6. For Python 2.4 and 2.5, the compiler is Visual Studio .NET 2003. :class:`MSVCCompiler` will normally choose the right compiler, linker etc. on its own. To override this choice, the environment variables *DISTUTILS_USE_SDK* and *MSSdk* must be both set. *MSSdk* indicates that the current environment has been setup by the SDK's ``SetEnv.Cmd`` script, or that the environment variables had been registered when the SDK was installed; *DISTUTILS_USE_SDK* indicates that the distutils user has made an explicit choice to override the compiler selection by :class:`MSVCCompiler`. :mod:`distutils.bcppcompiler` --- Borland Compiler ================================================== .. module:: distutils.bcppcompiler This module provides :class:`BorlandCCompiler`, a subclass of the abstract :class:`CCompiler` class for the Borland C++ compiler. :mod:`distutils.cygwinccompiler` --- Cygwin Compiler ==================================================== .. module:: distutils.cygwinccompiler This module provides the :class:`CygwinCCompiler` class, a subclass of :class:`UnixCCompiler` that handles the Cygwin port of the GNU C compiler to Windows. It also contains the Mingw32CCompiler class which handles the mingw32 port of GCC (same as cygwin in no-cygwin mode). :mod:`distutils.archive_util` --- Archiving utilities ====================================================== .. module:: distutils.archive_util :synopsis: Utility functions for creating archive files (tarballs, zip files, ...) This module provides a few functions for creating archive files, such as tarballs or zipfiles. .. function:: make_archive(base_name, format[, root_dir=None, base_dir=None, verbose=0, dry_run=0]) Create an archive file (eg. ``zip`` or ``tar``). *base_name* is the name of the file to create, minus any format-specific extension; *format* is the archive format: one of ``zip``, ``tar``, ``gztar``, ``bztar``, ``xztar``, or ``ztar``. *root_dir* is a directory that will be the root directory of the archive; ie. we typically ``chdir`` into *root_dir* before creating the archive. *base_dir* is the directory where we start archiving from; ie. *base_dir* will be the common prefix of all files and directories in the archive. *root_dir* and *base_dir* both default to the current directory. Returns the name of the archive file. .. versionchanged:: 3.5 Added support for the ``xztar`` format. .. function:: make_tarball(base_name, base_dir[, compress='gzip', verbose=0, dry_run=0]) 'Create an (optional compressed) archive as a tar file from all files in and under *base_dir*. *compress* must be ``'gzip'`` (the default), ``'bzip2'``, ``'xz'``, ``'compress'``, or ``None``. For the ``'compress'`` method the compression utility named by :program:`compress` must be on the default program search path, so this is probably Unix-specific. The output tar file will be named :file:`base_dir.tar`, possibly plus the appropriate compression extension (``.gz``, ``.bz2``, ``.xz`` or ``.Z``). Return the output filename. .. versionchanged:: 3.5 Added support for the ``xz`` compression. .. function:: make_zipfile(base_name, base_dir[, verbose=0, dry_run=0]) Create a zip file from all files in and under *base_dir*. The output zip file will be named *base_name* + :file:`.zip`. Uses either the :mod:`zipfile` Python module (if available) or the InfoZIP :file:`zip` utility (if installed and found on the default search path). If neither tool is available, raises :exc:`DistutilsExecError`. Returns the name of the output zip file. :mod:`distutils.dep_util` --- Dependency checking ================================================= .. module:: distutils.dep_util :synopsis: Utility functions for simple dependency checking This module provides functions for performing simple, timestamp-based dependency of files and groups of files; also, functions based entirely on such timestamp dependency analysis. .. function:: newer(source, target) Return true if *source* exists and is more recently modified than *target*, or if *source* exists and *target* doesn't. Return false if both exist and *target* is the same age or newer than *source*. Raise :exc:`DistutilsFileError` if *source* does not exist. .. function:: newer_pairwise(sources, targets) Walk two filename lists in parallel, testing if each source is newer than its corresponding target. Return a pair of lists (*sources*, *targets*) where source is newer than target, according to the semantics of :func:`newer`. .. % % equivalent to a listcomp... .. function:: newer_group(sources, target[, missing='error']) Return true if *target* is out-of-date with respect to any file listed in *sources*. In other words, if *target* exists and is newer than every file in *sources*, return false; otherwise return true. *missing* controls what we do when a source file is missing; the default (``'error'``) is to blow up with an :exc:`OSError` from inside :func:`os.stat`; if it is ``'ignore'``, we silently drop any missing source files; if it is ``'newer'``, any missing source files make us assume that *target* is out-of-date (this is handy in "dry-run" mode: it'll make you pretend to carry out commands that wouldn't work because inputs are missing, but that doesn't matter because you're not actually going to run the commands). :mod:`distutils.dir_util` --- Directory tree operations ======================================================= .. module:: distutils.dir_util :synopsis: Utility functions for operating on directories and directory trees This module provides functions for operating on directories and trees of directories. .. function:: mkpath(name[, mode=0o777, verbose=0, dry_run=0]) Create a directory and any missing ancestor directories. If the directory already exists (or if *name* is the empty string, which means the current directory, which of course exists), then do nothing. Raise :exc:`DistutilsFileError` if unable to create some directory along the way (eg. some sub-path exists, but is a file rather than a directory). If *verbose* is true, print a one-line summary of each mkdir to stdout. Return the list of directories actually created. .. function:: create_tree(base_dir, files[, mode=0o777, verbose=0, dry_run=0]) Create all the empty directories under *base_dir* needed to put *files* there. *base_dir* is just the name of a directory which doesn't necessarily exist yet; *files* is a list of filenames to be interpreted relative to *base_dir*. *base_dir* + the directory portion of every file in *files* will be created if it doesn't already exist. *mode*, *verbose* and *dry_run* flags are as for :func:`mkpath`. .. function:: copy_tree(src, dst[, preserve_mode=1, preserve_times=1, preserve_symlinks=0, update=0, verbose=0, dry_run=0]) Copy an entire directory tree *src* to a new location *dst*. Both *src* and *dst* must be directory names. If *src* is not a directory, raise :exc:`DistutilsFileError`. If *dst* does not exist, it is created with :func:`mkpath`. The end result of the copy is that every file in *src* is copied to *dst*, and directories under *src* are recursively copied to *dst*. Return the list of files that were copied or might have been copied, using their output name. The return value is unaffected by *update* or *dry_run*: it is simply the list of all files under *src*, with the names changed to be under *dst*. *preserve_mode* and *preserve_times* are the same as for :func:`distutils.file_util.copy_file`; note that they only apply to regular files, not to directories. If *preserve_symlinks* is true, symlinks will be copied as symlinks (on platforms that support them!); otherwise (the default), the destination of the symlink will be copied. *update* and *verbose* are the same as for :func:`~distutils.file_util.copy_file`. Files in *src* that begin with :file:`.nfs` are skipped (more information on these files is available in answer D2 of the `NFS FAQ page `_). .. versionchanged:: 3.3.1 NFS files are ignored. .. function:: remove_tree(directory[, verbose=0, dry_run=0]) Recursively remove *directory* and all files and directories underneath it. Any errors are ignored (apart from being reported to ``sys.stdout`` if *verbose* is true). :mod:`distutils.file_util` --- Single file operations ===================================================== .. module:: distutils.file_util :synopsis: Utility functions for operating on single files This module contains some utility functions for operating on individual files. .. function:: copy_file(src, dst[, preserve_mode=1, preserve_times=1, update=0, link=None, verbose=0, dry_run=0]) Copy file *src* to *dst*. If *dst* is a directory, then *src* is copied there with the same name; otherwise, it must be a filename. (If the file exists, it will be ruthlessly clobbered.) If *preserve_mode* is true (the default), the file's mode (type and permission bits, or whatever is analogous on the current platform) is copied. If *preserve_times* is true (the default), the last-modified and last-access times are copied as well. If *update* is true, *src* will only be copied if *dst* does not exist, or if *dst* does exist but is older than *src*. *link* allows you to make hard links (using :func:`os.link`) or symbolic links (using :func:`os.symlink`) instead of copying: set it to ``'hard'`` or ``'sym'``; if it is ``None`` (the default), files are copied. Don't set *link* on systems that don't support it: :func:`copy_file` doesn't check if hard or symbolic linking is available. It uses :func:`~distutils.file_util._copy_file_contents` to copy file contents. Return a tuple ``(dest_name, copied)``: *dest_name* is the actual name of the output file, and *copied* is true if the file was copied (or would have been copied, if *dry_run* true). .. % XXX if the destination file already exists, we clobber it if .. % copying, but blow up if linking. Hmmm. And I don't know what .. % macostools.copyfile() does. Should definitely be consistent, and .. % should probably blow up if destination exists and we would be .. % changing it (ie. it's not already a hard/soft link to src OR .. % (not update) and (src newer than dst)). .. function:: move_file(src, dst[, verbose, dry_run]) Move file *src* to *dst*. If *dst* is a directory, the file will be moved into it with the same name; otherwise, *src* is just renamed to *dst*. Returns the new full name of the file. .. warning:: Handles cross-device moves on Unix using :func:`copy_file`. What about other systems? .. function:: write_file(filename, contents) Create a file called *filename* and write *contents* (a sequence of strings without line terminators) to it. :mod:`distutils.util` --- Miscellaneous other utility functions =============================================================== .. module:: distutils.util :synopsis: Miscellaneous other utility functions This module contains other assorted bits and pieces that don't fit into any other utility module. .. function:: get_platform() Return a string that identifies the current platform. This is used mainly to distinguish platform-specific build directories and platform-specific built distributions. Typically includes the OS name and version and the architecture (as supplied by 'os.uname()'), although the exact information included depends on the OS; e.g., on Linux, the kernel version isn't particularly important. Examples of returned values: * ``linux-i586`` * ``linux-alpha`` * ``solaris-2.6-sun4u`` For non-POSIX platforms, currently just returns ``sys.platform``. For Mac OS X systems the OS version reflects the minimal version on which binaries will run (that is, the value of ``MACOSX_DEPLOYMENT_TARGET`` during the build of Python), not the OS version of the current system. For universal binary builds on Mac OS X the architecture value reflects the universal binary status instead of the architecture of the current processor. For 32-bit universal binaries the architecture is ``fat``, for 64-bit universal binaries the architecture is ``fat64``, and for 4-way universal binaries the architecture is ``universal``. Starting from Python 2.7 and Python 3.2 the architecture ``fat3`` is used for a 3-way universal build (ppc, i386, x86_64) and ``intel`` is used for a universal build with the i386 and x86_64 architectures Examples of returned values on Mac OS X: * ``macosx-10.3-ppc`` * ``macosx-10.3-fat`` * ``macosx-10.5-universal`` * ``macosx-10.6-intel`` For AIX, Python 3.9 and later return a string starting with "aix", followed by additional fields (separated by ``'-'``) that represent the combined values of AIX Version, Release and Technology Level (first field), Build Date (second field), and bit-size (third field). Python 3.8 and earlier returned only a single additional field with the AIX Version and Release. Examples of returned values on AIX: * ``aix-5307-0747-32`` # 32-bit build on AIX ``oslevel -s``: 5300-07-00-0000 * ``aix-7105-1731-64`` # 64-bit build on AIX ``oslevel -s``: 7100-05-01-1731 * ``aix-7.2`` # Legacy form reported in Python 3.8 and earlier .. versionchanged:: 3.9 The AIX platform string format now also includes the technology level, build date, and ABI bit-size. .. function:: convert_path(pathname) Return 'pathname' as a name that will work on the native filesystem, i.e. split it on '/' and put it back together again using the current directory separator. Needed because filenames in the setup script are always supplied in Unix style, and have to be converted to the local convention before we can actually use them in the filesystem. Raises :exc:`ValueError` on non-Unix-ish systems if *pathname* either starts or ends with a slash. .. function:: change_root(new_root, pathname) Return *pathname* with *new_root* prepended. If *pathname* is relative, this is equivalent to ``os.path.join(new_root,pathname)`` Otherwise, it requires making *pathname* relative and then joining the two, which is tricky on DOS/Windows. .. function:: check_environ() Ensure that 'os.environ' has all the environment variables we guarantee that users can use in config files, command-line options, etc. Currently this includes: * :envvar:`HOME` - user's home directory (Unix only) * :envvar:`PLAT` - description of the current platform, including hardware and OS (see :func:`get_platform`) .. function:: subst_vars(s, local_vars) Perform shell/Perl-style variable substitution on *s*. Every occurrence of ``$`` followed by a name is considered a variable, and variable is substituted by the value found in the *local_vars* dictionary, or in ``os.environ`` if it's not in *local_vars*. *os.environ* is first checked/augmented to guarantee that it contains certain values: see :func:`check_environ`. Raise :exc:`ValueError` for any variables not found in either *local_vars* or ``os.environ``. Note that this is not a fully-fledged string interpolation function. A valid ``$variable`` can consist only of upper and lower case letters, numbers and an underscore. No { } or ( ) style quoting is available. .. function:: split_quoted(s) Split a string up according to Unix shell-like rules for quotes and backslashes. In short: words are delimited by spaces, as long as those spaces are not escaped by a backslash, or inside a quoted string. Single and double quotes are equivalent, and the quote characters can be backslash-escaped. The backslash is stripped from any two-character escape sequence, leaving only the escaped character. The quote characters are stripped from any quoted string. Returns a list of words. .. % Should probably be moved into the standard library. .. function:: execute(func, args[, msg=None, verbose=0, dry_run=0]) Perform some action that affects the outside world (for instance, writing to the filesystem). Such actions are special because they are disabled by the *dry_run* flag. This method takes care of all that bureaucracy for you; all you have to do is supply the function to call and an argument tuple for it (to embody the "external action" being performed), and an optional message to print. .. function:: strtobool(val) Convert a string representation of truth to true (1) or false (0). True values are ``y``, ``yes``, ``t``, ``true``, ``on`` and ``1``; false values are ``n``, ``no``, ``f``, ``false``, ``off`` and ``0``. Raises :exc:`ValueError` if *val* is anything else. .. function:: byte_compile(py_files[, optimize=0, force=0, prefix=None, base_dir=None, verbose=1, dry_run=0, direct=None]) Byte-compile a collection of Python source files to :file:`.pyc` files in a :file:`__pycache__` subdirectory (see :pep:`3147` and :pep:`488`). *py_files* is a list of files to compile; any files that don't end in :file:`.py` are silently skipped. *optimize* must be one of the following: * ``0`` - don't optimize * ``1`` - normal optimization (like ``python -O``) * ``2`` - extra optimization (like ``python -OO``) If *force* is true, all files are recompiled regardless of timestamps. The source filename encoded in each :term:`bytecode` file defaults to the filenames listed in *py_files*; you can modify these with *prefix* and *basedir*. *prefix* is a string that will be stripped off of each source filename, and *base_dir* is a directory name that will be prepended (after *prefix* is stripped). You can supply either or both (or neither) of *prefix* and *base_dir*, as you wish. If *dry_run* is true, doesn't actually do anything that would affect the filesystem. Byte-compilation is either done directly in this interpreter process with the standard :mod:`py_compile` module, or indirectly by writing a temporary script and executing it. Normally, you should let :func:`byte_compile` figure out to use direct compilation or not (see the source for details). The *direct* flag is used by the script generated in indirect mode; unless you know what you're doing, leave it set to ``None``. .. versionchanged:: 3.2.3 Create ``.pyc`` files with an :func:`import magic tag ` in their name, in a :file:`__pycache__` subdirectory instead of files without tag in the current directory. .. versionchanged:: 3.5 Create ``.pyc`` files according to :pep:`488`. .. function:: rfc822_escape(header) Return a version of *header* escaped for inclusion in an :rfc:`822` header, by ensuring there are 8 spaces space after each newline. Note that it does no other modification of the string. .. % this _can_ be replaced .. % \subsection{Distutils objects} :mod:`distutils.dist` --- The Distribution class ================================================ .. module:: distutils.dist :synopsis: Provides the Distribution class, which represents the module distribution being built/installed/distributed This module provides the :class:`~distutils.core.Distribution` class, which represents the module distribution being built/installed/distributed. :mod:`distutils.extension` --- The Extension class ================================================== .. module:: distutils.extension :synopsis: Provides the Extension class, used to describe C/C++ extension modules in setup scripts This module provides the :class:`~distutils.extension.Extension` class, used to describe C/C++ extension modules in setup scripts. .. % \subsection{Ungrouped modules} .. % The following haven't been moved into a more appropriate section yet. :mod:`distutils.debug` --- Distutils debug mode =============================================== .. module:: distutils.debug :synopsis: Provides the debug flag for distutils This module provides the DEBUG flag. :mod:`distutils.errors` --- Distutils exceptions ================================================ .. module:: distutils.errors :synopsis: Provides standard distutils exceptions Provides exceptions used by the Distutils modules. Note that Distutils modules may raise standard exceptions; in particular, SystemExit is usually raised for errors that are obviously the end-user's fault (eg. bad command-line arguments). This module is safe to use in ``from ... import *`` mode; it only exports symbols whose names start with ``Distutils`` and end with ``Error``. :mod:`distutils.fancy_getopt` --- Wrapper around the standard getopt module =========================================================================== .. module:: distutils.fancy_getopt :synopsis: Additional getopt functionality This module provides a wrapper around the standard :mod:`getopt` module that provides the following additional features: * short and long options are tied together * options have help strings, so :func:`fancy_getopt` could potentially create a complete usage summary * options set attributes of a passed-in object * boolean options can have "negative aliases" --- eg. if :option:`!--quiet` is the "negative alias" of :option:`!--verbose`, then :option:`!--quiet` on the command line sets *verbose* to false. .. function:: fancy_getopt(options, negative_opt, object, args) Wrapper function. *options* is a list of ``(long_option, short_option, help_string)`` 3-tuples as described in the constructor for :class:`FancyGetopt`. *negative_opt* should be a dictionary mapping option names to option names, both the key and value should be in the *options* list. *object* is an object which will be used to store values (see the :meth:`~FancyGetopt.getopt` method of the :class:`FancyGetopt` class). *args* is the argument list. Will use ``sys.argv[1:]`` if you pass ``None`` as *args*. .. function:: wrap_text(text, width) Wraps *text* to less than *width* wide. .. class:: FancyGetopt([option_table=None]) The option_table is a list of 3-tuples: ``(long_option, short_option, help_string)`` If an option takes an argument, its *long_option* should have ``'='`` appended; *short_option* should just be a single character, no ``':'`` in any case. *short_option* should be ``None`` if a *long_option* doesn't have a corresponding *short_option*. All option tuples must have long options. The :class:`FancyGetopt` class provides the following methods: .. method:: FancyGetopt.getopt([args=None, object=None]) Parse command-line options in args. Store as attributes on *object*. If *args* is ``None`` or not supplied, uses ``sys.argv[1:]``. If *object* is ``None`` or not supplied, creates a new :class:`OptionDummy` instance, stores option values there, and returns a tuple ``(args, object)``. If *object* is supplied, it is modified in place and :func:`getopt` just returns *args*; in both cases, the returned *args* is a modified copy of the passed-in *args* list, which is left untouched. .. % and args returned are? .. method:: FancyGetopt.get_option_order() Returns the list of ``(option, value)`` tuples processed by the previous run of :meth:`getopt` Raises :exc:`RuntimeError` if :meth:`getopt` hasn't been called yet. .. method:: FancyGetopt.generate_help([header=None]) Generate help text (a list of strings, one per suggested line of output) from the option table for this :class:`FancyGetopt` object. If supplied, prints the supplied *header* at the top of the help. :mod:`distutils.filelist` --- The FileList class ================================================ .. module:: distutils.filelist :synopsis: The FileList class, used for poking about the file system and building lists of files. This module provides the :class:`FileList` class, used for poking about the filesystem and building lists of files. :mod:`distutils.log` --- Simple :pep:`282`-style logging ======================================================== .. module:: distutils.log :synopsis: A simple logging mechanism, :pep:`282`-style :mod:`distutils.spawn` --- Spawn a sub-process ============================================== .. module:: distutils.spawn :synopsis: Provides the spawn() function This module provides the :func:`~distutils.spawn.spawn` function, a front-end to various platform-specific functions for launching another program in a sub-process. Also provides :func:`~distutils.spawn.find_executable` to search the path for a given executable name. :mod:`distutils.sysconfig` --- System configuration information =============================================================== .. module:: distutils.sysconfig :synopsis: Low-level access to configuration information of the Python interpreter. .. moduleauthor:: Fred L. Drake, Jr. .. moduleauthor:: Greg Ward .. sectionauthor:: Fred L. Drake, Jr. The :mod:`distutils.sysconfig` module provides access to Python's low-level configuration information. The specific configuration variables available depend heavily on the platform and configuration. The specific variables depend on the build process for the specific version of Python being run; the variables are those found in the :file:`Makefile` and configuration header that are installed with Python on Unix systems. The configuration header is called :file:`pyconfig.h` for Python versions starting with 2.2, and :file:`config.h` for earlier versions of Python. Some additional functions are provided which perform some useful manipulations for other parts of the :mod:`distutils` package. .. data:: PREFIX The result of ``os.path.normpath(sys.prefix)``. .. data:: EXEC_PREFIX The result of ``os.path.normpath(sys.exec_prefix)``. .. function:: get_config_var(name) Return the value of a single variable. This is equivalent to ``get_config_vars().get(name)``. .. function:: get_config_vars(...) Return a set of variable definitions. If there are no arguments, this returns a dictionary mapping names of configuration variables to values. If arguments are provided, they should be strings, and the return value will be a sequence giving the associated values. If a given name does not have a corresponding value, ``None`` will be included for that variable. .. function:: get_config_h_filename() Return the full path name of the configuration header. For Unix, this will be the header generated by the :program:`configure` script; for other platforms the header will have been supplied directly by the Python source distribution. The file is a platform-specific text file. .. function:: get_makefile_filename() Return the full path name of the :file:`Makefile` used to build Python. For Unix, this will be a file generated by the :program:`configure` script; the meaning for other platforms will vary. The file is a platform-specific text file, if it exists. This function is only useful on POSIX platforms. .. function:: get_python_inc([plat_specific[, prefix]]) Return the directory for either the general or platform-dependent C include files. If *plat_specific* is true, the platform-dependent include directory is returned; if false or omitted, the platform-independent directory is returned. If *prefix* is given, it is used as either the prefix instead of :const:`PREFIX`, or as the exec-prefix instead of :const:`EXEC_PREFIX` if *plat_specific* is true. .. function:: get_python_lib([plat_specific[, standard_lib[, prefix]]]) Return the directory for either the general or platform-dependent library installation. If *plat_specific* is true, the platform-dependent include directory is returned; if false or omitted, the platform-independent directory is returned. If *prefix* is given, it is used as either the prefix instead of :const:`PREFIX`, or as the exec-prefix instead of :const:`EXEC_PREFIX` if *plat_specific* is true. If *standard_lib* is true, the directory for the standard library is returned rather than the directory for the installation of third-party extensions. The following function is only intended for use within the :mod:`distutils` package. .. function:: customize_compiler(compiler) Do any platform-specific customization of a :class:`distutils.ccompiler.CCompiler` instance. This function is only needed on Unix at this time, but should be called consistently to support forward-compatibility. It inserts the information that varies across Unix flavors and is stored in Python's :file:`Makefile`. This information includes the selected compiler, compiler and linker options, and the extension used by the linker for shared objects. This function is even more special-purpose, and should only be used from Python's own build procedures. .. function:: set_python_build() Inform the :mod:`distutils.sysconfig` module that it is being used as part of the build process for Python. This changes a lot of relative locations for files, allowing them to be located in the build area rather than in an installed Python. :mod:`distutils.text_file` --- The TextFile class ================================================= .. module:: distutils.text_file :synopsis: Provides the TextFile class, a simple interface to text files This module provides the :class:`TextFile` class, which gives an interface to text files that (optionally) takes care of stripping comments, ignoring blank lines, and joining lines with backslashes. .. class:: TextFile([filename=None, file=None, **options]) This class provides a file-like object that takes care of all the things you commonly want to do when processing a text file that has some line-by-line syntax: strip comments (as long as ``#`` is your comment character), skip blank lines, join adjacent lines by escaping the newline (ie. backslash at end of line), strip leading and/or trailing whitespace. All of these are optional and independently controllable. The class provides a :meth:`warn` method so you can generate warning messages that report physical line number, even if the logical line in question spans multiple physical lines. Also provides :meth:`unreadline` for implementing line-at-a-time lookahead. :class:`TextFile` instances are create with either *filename*, *file*, or both. :exc:`RuntimeError` is raised if both are ``None``. *filename* should be a string, and *file* a file object (or something that provides :meth:`readline` and :meth:`close` methods). It is recommended that you supply at least *filename*, so that :class:`TextFile` can include it in warning messages. If *file* is not supplied, :class:`TextFile` creates its own using the :func:`open` built-in function. The options are all boolean, and affect the values returned by :meth:`readline` .. tabularcolumns:: |l|L|l| +------------------+--------------------------------+---------+ | option name | description | default | +==================+================================+=========+ | *strip_comments* | strip from ``'#'`` to | true | | | end-of-line, as well as any | | | | whitespace leading up to the | | | | ``'#'``\ ---unless it is | | | | escaped by a backslash | | +------------------+--------------------------------+---------+ | *lstrip_ws* | strip leading whitespace from | false | | | each line before returning it | | +------------------+--------------------------------+---------+ | *rstrip_ws* | strip trailing whitespace | true | | | (including line terminator!) | | | | from each line before | | | | returning it. | | +------------------+--------------------------------+---------+ | *skip_blanks* | skip lines that are empty | true | | | \*after\* stripping comments | | | | and whitespace. (If both | | | | lstrip_ws and rstrip_ws are | | | | false, then some lines may | | | | consist of solely whitespace: | | | | these will \*not\* be skipped, | | | | even if *skip_blanks* is | | | | true.) | | +------------------+--------------------------------+---------+ | *join_lines* | if a backslash is the last | false | | | non-newline character on a | | | | line after stripping comments | | | | and whitespace, join the | | | | following line to it to form | | | | one logical line; if N | | | | consecutive lines end with a | | | | backslash, then N+1 physical | | | | lines will be joined to form | | | | one logical line. | | +------------------+--------------------------------+---------+ | *collapse_join* | strip leading whitespace from | false | | | lines that are joined to their | | | | predecessor; only matters if | | | | ``(join_lines and not | | | | lstrip_ws)`` | | +------------------+--------------------------------+---------+ Note that since *rstrip_ws* can strip the trailing newline, the semantics of :meth:`readline` must differ from those of the built-in file object's :meth:`readline` method! In particular, :meth:`readline` returns ``None`` for end-of-file: an empty string might just be a blank line (or an all-whitespace line), if *rstrip_ws* is true but *skip_blanks* is not. .. method:: TextFile.open(filename) Open a new file *filename*. This overrides any *file* or *filename* constructor arguments. .. method:: TextFile.close() Close the current file and forget everything we know about it (including the filename and the current line number). .. method:: TextFile.warn(msg[,line=None]) Print (to stderr) a warning message tied to the current logical line in the current file. If the current logical line in the file spans multiple physical lines, the warning refers to the whole range, such as ``"lines 3-5"``. If *line* is supplied, it overrides the current line number; it may be a list or tuple to indicate a range of physical lines, or an integer for a single physical line. .. method:: TextFile.readline() Read and return a single logical line from the current file (or from an internal buffer if lines have previously been "unread" with :meth:`unreadline`). If the *join_lines* option is true, this may involve reading multiple physical lines concatenated into a single string. Updates the current line number, so calling :meth:`warn` after :meth:`readline` emits a warning about the physical line(s) just read. Returns ``None`` on end-of-file, since the empty string can occur if *rstrip_ws* is true but *strip_blanks* is not. .. method:: TextFile.readlines() Read and return the list of all logical lines remaining in the current file. This updates the current line number to the last line of the file. .. method:: TextFile.unreadline(line) Push *line* (a string) onto an internal buffer that will be checked by future :meth:`readline` calls. Handy for implementing a parser with line-at-a-time lookahead. Note that lines that are "unread" with :meth:`unreadline` are not subsequently re-cleansed (whitespace stripped, or whatever) when read with :meth:`readline`. If multiple calls are made to :meth:`unreadline` before a call to :meth:`readline`, the lines will be returned most in most recent first order. :mod:`distutils.version` --- Version number classes =================================================== .. module:: distutils.version :synopsis: Implements classes that represent module version numbers. .. % todo .. % \section{Distutils Commands} .. % .. % This part of Distutils implements the various Distutils commands, such .. % as \code{build}, \code{install} \&c. Each command is implemented as a .. % separate module, with the command name as the name of the module. :mod:`distutils.cmd` --- Abstract base class for Distutils commands =================================================================== .. module:: distutils.cmd :synopsis: Provides the abstract base class :class:`~distutils.cmd.Command`. This class is subclassed by the modules in the distutils.command subpackage. This module supplies the abstract base class :class:`Command`. .. class:: Command(dist) Abstract base class for defining command classes, the "worker bees" of the Distutils. A useful analogy for command classes is to think of them as subroutines with local variables called *options*. The options are declared in :meth:`initialize_options` and defined (given their final values) in :meth:`finalize_options`, both of which must be defined by every command class. The distinction between the two is necessary because option values might come from the outside world (command line, config file, ...), and any options dependent on other options must be computed after these outside influences have been processed --- hence :meth:`finalize_options`. The body of the subroutine, where it does all its work based on the values of its options, is the :meth:`run` method, which must also be implemented by every command class. The class constructor takes a single argument *dist*, a :class:`~distutils.core.Distribution` instance. Creating a new Distutils command ================================ This section outlines the steps to create a new Distutils command. A new command lives in a module in the :mod:`distutils.command` package. There is a sample template in that directory called :file:`command_template`. Copy this file to a new module with the same name as the new command you're implementing. This module should implement a class with the same name as the module (and the command). So, for instance, to create the command ``peel_banana`` (so that users can run ``setup.py peel_banana``), you'd copy :file:`command_template` to :file:`distutils/command/peel_banana.py`, then edit it so that it's implementing the class ``peel_banana``, a subclass of :class:`distutils.cmd.Command`. Subclasses of :class:`Command` must define the following methods. .. method:: Command.initialize_options() Set default values for all the options that this command supports. Note that these defaults may be overridden by other commands, by the setup script, by config files, or by the command-line. Thus, this is not the place to code dependencies between options; generally, :meth:`initialize_options` implementations are just a bunch of ``self.foo = None`` assignments. .. method:: Command.finalize_options() Set final values for all the options that this command supports. This is always called as late as possible, ie. after any option assignments from the command-line or from other commands have been done. Thus, this is the place to code option dependencies: if *foo* depends on *bar*, then it is safe to set *foo* from *bar* as long as *foo* still has the same value it was assigned in :meth:`initialize_options`. .. method:: Command.run() A command's raison d'etre: carry out the action it exists to perform, controlled by the options initialized in :meth:`initialize_options`, customized by other commands, the setup script, the command-line, and config files, and finalized in :meth:`finalize_options`. All terminal output and filesystem interaction should be done by :meth:`run`. .. attribute:: Command.sub_commands *sub_commands* formalizes the notion of a "family" of commands, e.g. ``install`` as the parent with sub-commands ``install_lib``, ``install_headers``, etc. The parent of a family of commands defines *sub_commands* as a class attribute; it's a list of 2-tuples ``(command_name, predicate)``, with *command_name* a string and *predicate* a function, a string or ``None``. *predicate* is a method of the parent command that determines whether the corresponding command is applicable in the current situation. (E.g. ``install_headers`` is only applicable if we have any C header files to install.) If *predicate* is ``None``, that command is always applicable. *sub_commands* is usually defined at the *end* of a class, because predicates can be methods of the class, so they must already have been defined. The canonical example is the :command:`install` command. :mod:`distutils.command` --- Individual Distutils commands ========================================================== .. module:: distutils.command :synopsis: Contains one module for each standard Distutils command. .. % \subsubsection{Individual Distutils commands} .. % todo :mod:`distutils.command.bdist` --- Build a binary installer =========================================================== .. module:: distutils.command.bdist :synopsis: Build a binary installer for a package .. % todo :mod:`distutils.command.bdist_packager` --- Abstract base class for packagers ============================================================================= .. module:: distutils.command.bdist_packager :synopsis: Abstract base class for packagers .. % todo :mod:`distutils.command.bdist_dumb` --- Build a "dumb" installer ================================================================ .. module:: distutils.command.bdist_dumb :synopsis: Build a "dumb" installer - a simple archive of files :mod:`distutils.command.bdist_rpm` --- Build a binary distribution as a Redhat RPM and SRPM =========================================================================================== .. module:: distutils.command.bdist_rpm :synopsis: Build a binary distribution as a Redhat RPM and SRPM .. % todo :mod:`distutils.command.sdist` --- Build a source distribution ============================================================== .. module:: distutils.command.sdist :synopsis: Build a source distribution .. % todo :mod:`distutils.command.build` --- Build all files of a package =============================================================== .. module:: distutils.command.build :synopsis: Build all files of a package .. % todo :mod:`distutils.command.build_clib` --- Build any C libraries in a package ========================================================================== .. module:: distutils.command.build_clib :synopsis: Build any C libraries in a package .. % todo :mod:`distutils.command.build_ext` --- Build any extensions in a package ======================================================================== .. module:: distutils.command.build_ext :synopsis: Build any extensions in a package .. % todo :mod:`distutils.command.build_py` --- Build the .py/.pyc files of a package =========================================================================== .. module:: distutils.command.build_py :synopsis: Build the .py/.pyc files of a package .. class:: build_py :mod:`distutils.command.build_scripts` --- Build the scripts of a package ========================================================================= .. module:: distutils.command.build_scripts :synopsis: Build the scripts of a package .. % todo :mod:`distutils.command.clean` --- Clean a package build area ============================================================= .. module:: distutils.command.clean :synopsis: Clean a package build area This command removes the temporary files created by :command:`build` and its subcommands, like intermediary compiled object files. With the ``--all`` option, the complete build directory will be removed. Extension modules built :ref:`in place ` will not be cleaned, as they are not in the build directory. :mod:`distutils.command.config` --- Perform package configuration ================================================================= .. module:: distutils.command.config :synopsis: Perform package configuration .. % todo :mod:`distutils.command.install` --- Install a package ====================================================== .. module:: distutils.command.install :synopsis: Install a package .. % todo :mod:`distutils.command.install_data` --- Install data files from a package =========================================================================== .. module:: distutils.command.install_data :synopsis: Install data files from a package .. % todo :mod:`distutils.command.install_headers` --- Install C/C++ header files from a package ====================================================================================== .. module:: distutils.command.install_headers :synopsis: Install C/C++ header files from a package .. % todo :mod:`distutils.command.install_lib` --- Install library files from a package ============================================================================= .. module:: distutils.command.install_lib :synopsis: Install library files from a package .. % todo :mod:`distutils.command.install_scripts` --- Install script files from a package ================================================================================ .. module:: distutils.command.install_scripts :synopsis: Install script files from a package .. % todo :mod:`distutils.command.register` --- Register a module with the Python Package Index ===================================================================================== .. module:: distutils.command.register :synopsis: Register a module with the Python Package Index The ``register`` command registers the package with the Python Package Index. This is described in more detail in :pep:`301`. .. % todo :mod:`distutils.command.check` --- Check the meta-data of a package =================================================================== .. module:: distutils.command.check :synopsis: Check the meta-data of a package The ``check`` command performs some tests on the meta-data of a package. For example, it verifies that all required meta-data are provided as the arguments passed to the :func:`~distutils.core.setup` function. .. % todo ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/builtdist.rst0000644000175100001730000004562414467657412023276 0ustar00runnerdocker.. _built-dist: **************************** Creating Built Distributions **************************** .. include:: ./_setuptools_disclaimer.rst A "built distribution" is what you're probably used to thinking of either as a "binary package" or an "installer" (depending on your background). It's not necessarily binary, though, because it might contain only Python source code and/or byte-code; and we don't call it a package, because that word is already spoken for in Python. (And "installer" is a term specific to the world of mainstream desktop systems.) A built distribution is how you make life as easy as possible for installers of your module distribution: for users of RPM-based Linux systems, it's a binary RPM; for Windows users, it's an executable installer; for Debian-based Linux users, it's a Debian package; and so forth. Obviously, no one person will be able to create built distributions for every platform under the sun, so the Distutils are designed to enable module developers to concentrate on their specialty---writing code and creating source distributions---while an intermediary species called *packagers* springs up to turn source distributions into built distributions for as many platforms as there are packagers. Of course, the module developer could be their own packager; or the packager could be a volunteer "out there" somewhere who has access to a platform which the original developer does not; or it could be software periodically grabbing new source distributions and turning them into built distributions for as many platforms as the software has access to. Regardless of who they are, a packager uses the setup script and the :command:`bdist` command family to generate built distributions. As a simple example, if I run the following command in the Distutils source tree:: python setup.py bdist then the Distutils builds my module distribution (the Distutils itself in this case), does a "fake" installation (also in the :file:`build` directory), and creates the default type of built distribution for my platform. The default format for built distributions is a "dumb" tar file on Unix, and a simple executable installer on Windows. (That tar file is considered "dumb" because it has to be unpacked in a specific location to work.) Thus, the above command on a Unix system creates :file:`Distutils-1.0.{plat}.tar.gz`; unpacking this tarball from the right place installs the Distutils just as though you had downloaded the source distribution and run ``python setup.py install``. (The "right place" is either the root of the filesystem or Python's :file:`{prefix}` directory, depending on the options given to the :command:`bdist_dumb` command; the default is to make dumb distributions relative to :file:`{prefix}`.) Obviously, for pure Python distributions, this isn't any simpler than just running ``python setup.py install``\ ---but for non-pure distributions, which include extensions that would need to be compiled, it can mean the difference between someone being able to use your extensions or not. And creating "smart" built distributions, such as an RPM package or an executable installer for Windows, is far more convenient for users even if your distribution doesn't include any extensions. The :command:`bdist` command has a :option:`!--formats` option, similar to the :command:`sdist` command, which you can use to select the types of built distribution to generate: for example, :: python setup.py bdist --format=zip would, when run on a Unix system, create :file:`Distutils-1.0.{plat}.zip`\ ---again, this archive would be unpacked from the root directory to install the Distutils. The available formats for built distributions are: +-------------+------------------------------+---------+ | Format | Description | Notes | +=============+==============================+=========+ | ``gztar`` | gzipped tar file | \(1) | | | (:file:`.tar.gz`) | | +-------------+------------------------------+---------+ | ``bztar`` | bzipped tar file | | | | (:file:`.tar.bz2`) | | +-------------+------------------------------+---------+ | ``xztar`` | xzipped tar file | | | | (:file:`.tar.xz`) | | +-------------+------------------------------+---------+ | ``ztar`` | compressed tar file | \(3) | | | (:file:`.tar.Z`) | | +-------------+------------------------------+---------+ | ``tar`` | tar file (:file:`.tar`) | | +-------------+------------------------------+---------+ | ``zip`` | zip file (:file:`.zip`) | (2),(4) | +-------------+------------------------------+---------+ | ``rpm`` | RPM | \(5) | +-------------+------------------------------+---------+ | ``pkgtool`` | Solaris :program:`pkgtool` | | +-------------+------------------------------+---------+ | ``sdux`` | HP-UX :program:`swinstall` | | +-------------+------------------------------+---------+ .. versionchanged:: 3.5 Added support for the ``xztar`` format. Notes: (1) default on Unix (2) default on Windows (3) requires external :program:`compress` utility. (4) requires either external :program:`zip` utility or :mod:`zipfile` module (part of the standard Python library since Python 1.6) (5) requires external :program:`rpm` utility, version 3.0.4 or better (use ``rpm --version`` to find out which version you have) You don't have to use the :command:`bdist` command with the :option:`!--formats` option; you can also use the command that directly implements the format you're interested in. Some of these :command:`bdist` "sub-commands" actually generate several similar formats; for instance, the :command:`bdist_dumb` command generates all the "dumb" archive formats (``tar``, ``gztar``, ``bztar``, ``xztar``, ``ztar``, and ``zip``), and :command:`bdist_rpm` generates both binary and source RPMs. The :command:`bdist` sub-commands, and the formats generated by each, are: +--------------------------+-------------------------------------+ | Command | Formats | +==========================+=====================================+ | :command:`bdist_dumb` | tar, gztar, bztar, xztar, ztar, zip | +--------------------------+-------------------------------------+ | :command:`bdist_rpm` | rpm, srpm | +--------------------------+-------------------------------------+ The following sections give details on the individual :command:`bdist_\*` commands. .. .. _creating-dumb: .. Creating dumb built distributions .. ================================= .. XXX Need to document absolute vs. prefix-relative packages here, but first I have to implement it! .. _creating-rpms: Creating RPM packages ===================== The RPM format is used by many popular Linux distributions, including Red Hat, SuSE, and Mandrake. If one of these (or any of the other RPM-based Linux distributions) is your usual environment, creating RPM packages for other users of that same distribution is trivial. Depending on the complexity of your module distribution and differences between Linux distributions, you may also be able to create RPMs that work on different RPM-based distributions. The usual way to create an RPM of your module distribution is to run the :command:`bdist_rpm` command:: python setup.py bdist_rpm or the :command:`bdist` command with the :option:`!--format` option:: python setup.py bdist --formats=rpm The former allows you to specify RPM-specific options; the latter allows you to easily specify multiple formats in one run. If you need to do both, you can explicitly specify multiple :command:`bdist_\*` commands and their options:: python setup.py bdist_rpm --packager="John Doe " \ bdist_dumb --dumb-option=foo Creating RPM packages is driven by a :file:`.spec` file, much as using the Distutils is driven by the setup script. To make your life easier, the :command:`bdist_rpm` command normally creates a :file:`.spec` file based on the information you supply in the setup script, on the command line, and in any Distutils configuration files. Various options and sections in the :file:`.spec` file are derived from options in the setup script as follows: +------------------------------------------+----------------------------------------------+ | RPM :file:`.spec` file option or section | Distutils setup script option | +==========================================+==============================================+ | Name | ``name`` | +------------------------------------------+----------------------------------------------+ | Summary (in preamble) | ``description`` | +------------------------------------------+----------------------------------------------+ | Version | ``version`` | +------------------------------------------+----------------------------------------------+ | Vendor | ``author`` and ``author_email``, | | | or --- & ``maintainer`` and | | | ``maintainer_email`` | +------------------------------------------+----------------------------------------------+ | Copyright | ``license`` | +------------------------------------------+----------------------------------------------+ | Url | ``url`` | +------------------------------------------+----------------------------------------------+ | %description (section) | ``long_description`` | +------------------------------------------+----------------------------------------------+ Additionally, there are many options in :file:`.spec` files that don't have corresponding options in the setup script. Most of these are handled through options to the :command:`bdist_rpm` command as follows: +-------------------------------+-----------------------------+-------------------------+ | RPM :file:`.spec` file option | :command:`bdist_rpm` option | default value | | or section | | | +===============================+=============================+=========================+ | Release | ``release`` | "1" | +-------------------------------+-----------------------------+-------------------------+ | Group | ``group`` | "Development/Libraries" | +-------------------------------+-----------------------------+-------------------------+ | Vendor | ``vendor`` | (see above) | +-------------------------------+-----------------------------+-------------------------+ | Packager | ``packager`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Provides | ``provides`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Requires | ``requires`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Conflicts | ``conflicts`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Obsoletes | ``obsoletes`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Distribution | ``distribution_name`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | BuildRequires | ``build_requires`` | (none) | +-------------------------------+-----------------------------+-------------------------+ | Icon | ``icon`` | (none) | +-------------------------------+-----------------------------+-------------------------+ Obviously, supplying even a few of these options on the command-line would be tedious and error-prone, so it's usually best to put them in the setup configuration file, :file:`setup.cfg`\ ---see section :ref:`setup-config`. If you distribute or package many Python module distributions, you might want to put options that apply to all of them in your personal Distutils configuration file (:file:`~/.pydistutils.cfg`). If you want to temporarily disable this file, you can pass the :option:`!--no-user-cfg` option to :file:`setup.py`. There are three steps to building a binary RPM package, all of which are handled automatically by the Distutils: #. create a :file:`.spec` file, which describes the package (analogous to the Distutils setup script; in fact, much of the information in the setup script winds up in the :file:`.spec` file) #. create the source RPM #. create the "binary" RPM (which may or may not contain binary code, depending on whether your module distribution contains Python extensions) Normally, RPM bundles the last two steps together; when you use the Distutils, all three steps are typically bundled together. If you wish, you can separate these three steps. You can use the :option:`!--spec-only` option to make :command:`bdist_rpm` just create the :file:`.spec` file and exit; in this case, the :file:`.spec` file will be written to the "distribution directory"---normally :file:`dist/`, but customizable with the :option:`!--dist-dir` option. (Normally, the :file:`.spec` file winds up deep in the "build tree," in a temporary directory created by :command:`bdist_rpm`.) .. % \XXX{this isn't implemented yet---is it needed?!} .. % You can also specify a custom \file{.spec} file with the .. % \longprogramopt{spec-file} option; used in conjunction with .. % \longprogramopt{spec-only}, this gives you an opportunity to customize .. % the \file{.spec} file manually: .. % .. % \ begin{verbatim} .. % > python setup.py bdist_rpm --spec-only .. % # ...edit dist/FooBar-1.0.spec .. % > python setup.py bdist_rpm --spec-file=dist/FooBar-1.0.spec .. % \ end{verbatim} .. % .. % (Although a better way to do this is probably to override the standard .. % \command{bdist\_rpm} command with one that writes whatever else you want .. % to the \file{.spec} file.) .. _cross-compile-windows: Cross-compiling on Windows ========================== Starting with Python 2.6, distutils is capable of cross-compiling between Windows platforms. In practice, this means that with the correct tools installed, you can use a 32bit version of Windows to create 64bit extensions and vice-versa. To build for an alternate platform, specify the :option:`!--plat-name` option to the build command. Valid values are currently 'win32', and 'win-amd64'. For example, on a 32bit version of Windows, you could execute:: python setup.py build --plat-name=win-amd64 to build a 64bit version of your extension. To cross-compile, you must download the Python source code and cross-compile Python itself for the platform you are targeting - it is not possible from a binary installation of Python (as the .lib etc file for other platforms are not included.) In practice, this means the user of a 32 bit operating system will need to use Visual Studio 2008 to open the :file:`PCbuild/PCbuild.sln` solution in the Python source tree and build the "x64" configuration of the 'pythoncore' project before cross-compiling extensions is possible. Note that by default, Visual Studio 2008 does not install 64bit compilers or tools. You may need to reexecute the Visual Studio setup process and select these tools (using Control Panel->[Add/Remove] Programs is a convenient way to check or modify your existing install.) .. _postinstallation-script: The Postinstallation script --------------------------- Starting with Python 2.3, a postinstallation script can be specified with the :option:`!--install-script` option. The basename of the script must be specified, and the script filename must also be listed in the scripts argument to the setup function. This script will be run at installation time on the target system after all the files have been copied, with ``argv[1]`` set to :option:`!-install`, and again at uninstallation time before the files are removed with ``argv[1]`` set to :option:`!-remove`. The installation script runs embedded in the windows installer, every output (``sys.stdout``, ``sys.stderr``) is redirected into a buffer and will be displayed in the GUI after the script has finished. Some functions especially useful in this context are available as additional built-in functions in the installation script. .. function:: directory_created(path) file_created(path) These functions should be called when a directory or file is created by the postinstall script at installation time. It will register *path* with the uninstaller, so that it will be removed when the distribution is uninstalled. To be safe, directories are only removed if they are empty. .. function:: get_special_folder_path(csidl_string) This function can be used to retrieve special folder locations on Windows like the Start Menu or the Desktop. It returns the full path to the folder. *csidl_string* must be one of the following strings:: "CSIDL_APPDATA" "CSIDL_COMMON_STARTMENU" "CSIDL_STARTMENU" "CSIDL_COMMON_DESKTOPDIRECTORY" "CSIDL_DESKTOPDIRECTORY" "CSIDL_COMMON_STARTUP" "CSIDL_STARTUP" "CSIDL_COMMON_PROGRAMS" "CSIDL_PROGRAMS" "CSIDL_FONTS" If the folder cannot be retrieved, :exc:`OSError` is raised. Which folders are available depends on the exact Windows version, and probably also the configuration. For details refer to Microsoft's documentation of the :c:func:`SHGetSpecialFolderPath` function. .. function:: create_shortcut(target, description, filename[, arguments[, workdir[, iconpath[, iconindex]]]]) This function creates a shortcut. *target* is the path to the program to be started by the shortcut. *description* is the description of the shortcut. *filename* is the title of the shortcut that the user will see. *arguments* specifies the command line arguments, if any. *workdir* is the working directory for the program. *iconpath* is the file containing the icon for the shortcut, and *iconindex* is the index of the icon in the file *iconpath*. Again, for details consult the Microsoft documentation for the :class:`IShellLink` interface. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/commandref.rst0000644000175100001730000001075014467657412023376 0ustar00runnerdocker.. _reference: ***************** Command Reference ***************** .. include:: ./_setuptools_disclaimer.rst .. % \section{Building modules: the \protect\command{build} command family} .. % \label{build-cmds} .. % \subsubsection{\protect\command{build}} .. % \label{build-cmd} .. % \subsubsection{\protect\command{build\_py}} .. % \label{build-py-cmd} .. % \subsubsection{\protect\command{build\_ext}} .. % \label{build-ext-cmd} .. % \subsubsection{\protect\command{build\_clib}} .. % \label{build-clib-cmd} .. _install-cmd: Installing modules: the :command:`install` command family ========================================================= The install command ensures that the build commands have been run and then runs the subcommands :command:`install_lib`, :command:`install_data` and :command:`install_scripts`. .. % \subsubsection{\protect\command{install\_lib}} .. % \label{install-lib-cmd} .. _install-data-cmd: :command:`install_data` ----------------------- This command installs all data files provided with the distribution. .. _install-scripts-cmd: :command:`install_scripts` -------------------------- This command installs all (Python) scripts in the distribution. .. % \subsection{Cleaning up: the \protect\command{clean} command} .. % \label{clean-cmd} .. _sdist-cmd: Creating a source distribution: the :command:`sdist` command ============================================================ .. XXX fragment moved down from above: needs context! The manifest template commands are: +-------------------------------------------+-----------------------------------------------+ | Command | Description | +===========================================+===============================================+ | :command:`include pat1 pat2 ...` | include all files matching any of the listed | | | patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`exclude pat1 pat2 ...` | exclude all files matching any of the listed | | | patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`recursive-include dir pat1 pat2 | include all files under *dir* matching any of | | ...` | the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`recursive-exclude dir pat1 pat2 | exclude all files under *dir* matching any of | | ...` | the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`global-include pat1 pat2 ...` | include all files anywhere in the source tree | | | matching --- & any of the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`global-exclude pat1 pat2 ...` | exclude all files anywhere in the source tree | | | matching --- & any of the listed patterns | +-------------------------------------------+-----------------------------------------------+ | :command:`prune dir` | exclude all files under *dir* | +-------------------------------------------+-----------------------------------------------+ | :command:`graft dir` | include all files under *dir* | +-------------------------------------------+-----------------------------------------------+ The patterns here are Unix-style "glob" patterns: ``*`` matches any sequence of regular filename characters, ``?`` matches any single regular filename character, and ``[range]`` matches any of the characters in *range* (e.g., ``a-z``, ``a-zA-Z``, ``a-f0-9_.``). The definition of "regular filename character" is platform-specific: on Unix it is anything except slash; on Windows anything except backslash or colon. .. XXX Windows support not there yet .. % \section{Creating a built distribution: the .. % \protect\command{bdist} command family} .. % \label{bdist-cmds} .. % \subsection{\protect\command{bdist}} .. % \subsection{\protect\command{bdist\_dumb}} .. % \subsection{\protect\command{bdist\_rpm}} ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/configfile.rst0000644000175100001730000001375614467657412023401 0ustar00runnerdocker.. _setup-config: ************************************ Writing the Setup Configuration File ************************************ .. include:: ./_setuptools_disclaimer.rst Often, it's not possible to write down everything needed to build a distribution *a priori*: you may need to get some information from the user, or from the user's system, in order to proceed. As long as that information is fairly simple---a list of directories to search for C header files or libraries, for example---then providing a configuration file, :file:`setup.cfg`, for users to edit is a cheap and easy way to solicit it. Configuration files also let you provide default values for any command option, which the installer can then override either on the command-line or by editing the config file. The setup configuration file is a useful middle-ground between the setup script---which, ideally, would be opaque to installers [#]_---and the command-line to the setup script, which is outside of your control and entirely up to the installer. In fact, :file:`setup.cfg` (and any other Distutils configuration files present on the target system) are processed after the contents of the setup script, but before the command-line. This has several useful consequences: .. % (If you have more advanced needs, such as determining which extensions .. % to build based on what capabilities are present on the target system, .. % then you need the Distutils ``auto-configuration'' facility. This .. % started to appear in Distutils 0.9 but, as of this writing, isn't mature .. % or stable enough yet for real-world use.) * installers can override some of what you put in :file:`setup.py` by editing :file:`setup.cfg` * you can provide non-standard defaults for options that are not easily set in :file:`setup.py` * installers can override anything in :file:`setup.cfg` using the command-line options to :file:`setup.py` or by pointing :envvar:`DIST_EXTRA_CONFIG` to another configuration file The basic syntax of the configuration file is simple: .. code-block:: ini [command] option=value ... where *command* is one of the Distutils commands (e.g. :command:`build_py`, :command:`install`), and *option* is one of the options that command supports. Any number of options can be supplied for each command, and any number of command sections can be included in the file. Blank lines are ignored, as are comments, which run from a ``'#'`` character until the end of the line. Long option values can be split across multiple lines simply by indenting the continuation lines. You can find out the list of options supported by a particular command with the universal :option:`!--help` option, e.g. .. code-block:: shell-session $ python setup.py --help build_ext [...] Options for 'build_ext' command: --build-lib (-b) directory for compiled extension modules --build-temp (-t) directory for temporary files (build by-products) --inplace (-i) ignore build-lib and put compiled extensions into the source directory alongside your pure Python modules --include-dirs (-I) list of directories to search for header files --define (-D) C preprocessor macros to define --undef (-U) C preprocessor macros to undefine --swig-opts list of SWIG command line options [...] Note that an option spelled :option:`!--foo-bar` on the command-line is spelled ``foo_bar`` in configuration files. .. _distutils-build-ext-inplace: For example, say you want your extensions to be built "in-place"---that is, you have an extension ``pkg.ext``, and you want the compiled extension file (:file:`ext.so` on Unix, say) to be put in the same source directory as your pure Python modules ``pkg.mod1`` and ``pkg.mod2``. You can always use the :option:`!--inplace` option on the command-line to ensure this: .. code-block:: sh python setup.py build_ext --inplace But this requires that you always specify the :command:`build_ext` command explicitly, and remember to provide :option:`!--inplace`. An easier way is to "set and forget" this option, by encoding it in :file:`setup.cfg`, the configuration file for this distribution: .. code-block:: ini [build_ext] inplace=1 This will affect all builds of this module distribution, whether or not you explicitly specify :command:`build_ext`. If you include :file:`setup.cfg` in your source distribution, it will also affect end-user builds---which is probably a bad idea for this option, since always building extensions in-place would break installation of the module distribution. In certain peculiar cases, though, modules are built right in their installation directory, so this is conceivably a useful ability. (Distributing extensions that expect to be built in their installation directory is almost always a bad idea, though.) Another example: certain commands take a lot of options that don't change from run to run; for example, :command:`bdist_rpm` needs to know everything required to generate a "spec" file for creating an RPM distribution. Some of this information comes from the setup script, and some is automatically generated by the Distutils (such as the list of files installed). But some of it has to be supplied as options to :command:`bdist_rpm`, which would be very tedious to do on the command-line for every run. Hence, here is a snippet from the Distutils' own :file:`setup.cfg`: .. code-block:: ini [bdist_rpm] release = 1 packager = Greg Ward doc_files = CHANGES.txt README.txt USAGE.txt doc/ examples/ Note that the ``doc_files`` option is simply a whitespace-separated string split across multiple lines for readability. .. seealso:: :ref:`inst-config-syntax` in "Installing Python Modules" More information on the configuration files is available in the manual for system administrators. .. rubric:: Footnotes .. [#] This ideal probably won't be achieved until auto-configuration is fully supported by the Distutils. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/examples.rst0000644000175100001730000002401614467657412023101 0ustar00runnerdocker.. _distutils_examples: ****************** Distutils Examples ****************** .. include:: ./_setuptools_disclaimer.rst This chapter provides a number of basic examples to help get started with distutils. Additional information about using distutils can be found in the Distutils Cookbook. .. seealso:: `Distutils Cookbook `_ Collection of recipes showing how to achieve more control over distutils. .. _pure-mod: Pure Python distribution (by module) ==================================== If you're just distributing a couple of modules, especially if they don't live in a particular package, you can specify them individually using the ``py_modules`` option in the setup script. In the simplest case, you'll have two files to worry about: a setup script and the single module you're distributing, :file:`foo.py` in this example:: / setup.py foo.py (In all diagrams in this section, ** will refer to the distribution root directory.) A minimal setup script to describe this situation would be:: from distutils.core import setup setup(name='foo', version='1.0', py_modules=['foo'], ) Note that the name of the distribution is specified independently with the ``name`` option, and there's no rule that says it has to be the same as the name of the sole module in the distribution (although that's probably a good convention to follow). However, the distribution name is used to generate filenames, so you should stick to letters, digits, underscores, and hyphens. Since ``py_modules`` is a list, you can of course specify multiple modules, eg. if you're distributing modules ``foo`` and ``bar``, your setup might look like this:: / setup.py foo.py bar.py and the setup script might be :: from distutils.core import setup setup(name='foobar', version='1.0', py_modules=['foo', 'bar'], ) You can put module source files into another directory, but if you have enough modules to do that, it's probably easier to specify modules by package rather than listing them individually. .. _pure-pkg: Pure Python distribution (by package) ===================================== If you have more than a couple of modules to distribute, especially if they are in multiple packages, it's probably easier to specify whole packages rather than individual modules. This works even if your modules are not in a package; you can just tell the Distutils to process modules from the root package, and that works the same as any other package (except that you don't have to have an :file:`__init__.py` file). The setup script from the last example could also be written as :: from distutils.core import setup setup(name='foobar', version='1.0', packages=[''], ) (The empty string stands for the root package.) If those two files are moved into a subdirectory, but remain in the root package, e.g.:: / setup.py src/ foo.py bar.py then you would still specify the root package, but you have to tell the Distutils where source files in the root package live:: from distutils.core import setup setup(name='foobar', version='1.0', package_dir={'': 'src'}, packages=[''], ) More typically, though, you will want to distribute multiple modules in the same package (or in sub-packages). For example, if the ``foo`` and ``bar`` modules belong in package ``foobar``, one way to layout your source tree is :: / setup.py foobar/ __init__.py foo.py bar.py This is in fact the default layout expected by the Distutils, and the one that requires the least work to describe in your setup script:: from distutils.core import setup setup(name='foobar', version='1.0', packages=['foobar'], ) If you want to put modules in directories not named for their package, then you need to use the ``package_dir`` option again. For example, if the :file:`src` directory holds modules in the ``foobar`` package:: / setup.py src/ __init__.py foo.py bar.py an appropriate setup script would be :: from distutils.core import setup setup(name='foobar', version='1.0', package_dir={'foobar': 'src'}, packages=['foobar'], ) Or, you might put modules from your main package right in the distribution root:: / setup.py __init__.py foo.py bar.py in which case your setup script would be :: from distutils.core import setup setup(name='foobar', version='1.0', package_dir={'foobar': ''}, packages=['foobar'], ) (The empty string also stands for the current directory.) If you have sub-packages, they must be explicitly listed in ``packages``, but any entries in ``package_dir`` automatically extend to sub-packages. (In other words, the Distutils does *not* scan your source tree, trying to figure out which directories correspond to Python packages by looking for :file:`__init__.py` files.) Thus, if the default layout grows a sub-package:: / setup.py foobar/ __init__.py foo.py bar.py subfoo/ __init__.py blah.py then the corresponding setup script would be :: from distutils.core import setup setup(name='foobar', version='1.0', packages=['foobar', 'foobar.subfoo'], ) .. _single-ext: Single extension module ======================= Extension modules are specified using the ``ext_modules`` option. ``package_dir`` has no effect on where extension source files are found; it only affects the source for pure Python modules. The simplest case, a single extension module in a single C source file, is:: / setup.py foo.c If the ``foo`` extension belongs in the root package, the setup script for this could be :: from distutils.core import setup from distutils.extension import Extension setup(name='foobar', version='1.0', ext_modules=[Extension('foo', ['foo.c'])], ) If the extension actually belongs in a package, say ``foopkg``, then With exactly the same source tree layout, this extension can be put in the ``foopkg`` package simply by changing the name of the extension:: from distutils.core import setup from distutils.extension import Extension setup(name='foobar', version='1.0', ext_modules=[Extension('foopkg.foo', ['foo.c'])], ) Checking a package ================== The ``check`` command allows you to verify if your package meta-data meet the minimum requirements to build a distribution. To run it, just call it using your :file:`setup.py` script. If something is missing, ``check`` will display a warning. Let's take an example with a simple script:: from distutils.core import setup setup(name='foobar') Running the ``check`` command will display some warnings: .. code-block:: shell-session $ python setup.py check running check warning: check: missing required meta-data: version If you use the reStructuredText syntax in the ``long_description`` field and `docutils`_ is installed you can check if the syntax is fine with the ``check`` command, using the ``restructuredtext`` option. For example, if the :file:`setup.py` script is changed like this:: from distutils.core import setup desc = """\ My description ============== This is the description of the ``foobar`` package. """ setup(name='foobar', version='1', author='tarek', author_email='tarek@ziade.org', url='http://example.com', long_description=desc) Where the long description is broken, ``check`` will be able to detect it by using the :mod:`docutils` parser: .. code-block:: shell-session $ python setup.py check --restructuredtext running check warning: check: Title underline too short. (line 2) warning: check: Could not finish the parsing. Reading the metadata ===================== The :func:`distutils.core.setup` function provides a command-line interface that allows you to query the metadata fields of a project through the ``setup.py`` script of a given project: .. code-block:: shell-session $ python setup.py --name distribute This call reads the ``name`` metadata by running the :func:`distutils.core.setup` function. Although, when a source or binary distribution is created with Distutils, the metadata fields are written in a static file called :file:`PKG-INFO`. When a Distutils-based project is installed in Python, the :file:`PKG-INFO` file is copied alongside the modules and packages of the distribution under :file:`NAME-VERSION-pyX.X.egg-info`, where ``NAME`` is the name of the project, ``VERSION`` its version as defined in the Metadata, and ``pyX.X`` the major and minor version of Python like ``2.7`` or ``3.2``. You can read back this static file, by using the :class:`distutils.dist.DistributionMetadata` class and its :func:`~distutils.dist.DistributionMetadata.read_pkg_file` method:: >>> from distutils.dist import DistributionMetadata >>> metadata = DistributionMetadata() >>> metadata.read_pkg_file(open('distribute-0.6.8-py2.7.egg-info')) >>> metadata.name 'distribute' >>> metadata.version '0.6.8' >>> metadata.description 'Easily download, build, install, upgrade, and uninstall Python packages' Notice that the class can also be instantiated with a metadata file path to loads its values:: >>> pkg_info_path = 'distribute-0.6.8-py2.7.egg-info' >>> DistributionMetadata(pkg_info_path).name 'distribute' .. % \section{Multiple extension modules} .. % \label{multiple-ext} .. % \section{Putting it all together} .. _docutils: http://docutils.sourceforge.net ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/extending.rst0000644000175100001730000001075614467657412023256 0ustar00runnerdocker.. _extending-distutils: ******************* Extending Distutils ******************* .. include:: ./_setuptools_disclaimer.rst Distutils can be extended in various ways. Most extensions take the form of new commands or replacements for existing commands. New commands may be written to support new types of platform-specific packaging, for example, while replacements for existing commands may be made to modify details of how the command operates on a package. Most extensions of the distutils are made within :file:`setup.py` scripts that want to modify existing commands; many simply add a few file extensions that should be copied into packages in addition to :file:`.py` files as a convenience. Most distutils command implementations are subclasses of the :class:`distutils.cmd.Command` class. New commands may directly inherit from :class:`~distutils.cmd.Command`, while replacements often derive from :class:`~distutils.cmd.Command` indirectly, directly subclassing the command they are replacing. Commands are required to derive from :class:`~distutils.cmd.Command`. .. % \section{Extending existing commands} .. % \label{extend-existing} .. % \section{Writing new commands} .. % \label{new-commands} .. % \XXX{Would an uninstall command be a good example here?} Integrating new commands ======================== There are different ways to integrate new command implementations into distutils. The most difficult is to lobby for the inclusion of the new features in distutils itself, and wait for (and require) a version of Python that provides that support. This is really hard for many reasons. The most common, and possibly the most reasonable for most needs, is to include the new implementations with your :file:`setup.py` script, and cause the :func:`distutils.core.setup` function use them:: from distutils.command.build_py import build_py as _build_py from distutils.core import setup class build_py(_build_py): """Specialized Python source builder.""" # implement whatever needs to be different... setup(cmdclass={'build_py': build_py}, ...) This approach is most valuable if the new implementations must be used to use a particular package, as everyone interested in the package will need to have the new command implementation. Beginning with Python 2.4, a third option is available, intended to allow new commands to be added which can support existing :file:`setup.py` scripts without requiring modifications to the Python installation. This is expected to allow third-party extensions to provide support for additional packaging systems, but the commands can be used for anything distutils commands can be used for. A new configuration option, ``command_packages`` (command-line option :option:`!--command-packages`), can be used to specify additional packages to be searched for modules implementing commands. Like all distutils options, this can be specified on the command line or in a configuration file. This option can only be set in the ``[global]`` section of a configuration file, or before any commands on the command line. If set in a configuration file, it can be overridden from the command line; setting it to an empty string on the command line causes the default to be used. This should never be set in a configuration file provided with a package. This new option can be used to add any number of packages to the list of packages searched for command implementations; multiple package names should be separated by commas. When not specified, the search is only performed in the :mod:`distutils.command` package. When :file:`setup.py` is run with the option ``--command-packages distcmds,buildcmds``, however, the packages :mod:`distutils.command`, ``distcmds``, and ``buildcmds`` will be searched in that order. New commands are expected to be implemented in modules of the same name as the command by classes sharing the same name. Given the example command line option above, the command :command:`bdist_openpkg` could be implemented by the class ``distcmds.bdist_openpkg.bdist_openpkg`` or ``buildcmds.bdist_openpkg.bdist_openpkg``. Adding new distribution types ============================= Commands that create distributions (files in the :file:`dist/` directory) need to add ``(command, filename)`` pairs to ``self.distribution.dist_files`` so that :command:`upload` can upload it to PyPI. The *filename* in the pair contains no path information, only the name of the file itself. In dry-run mode, pairs should still be added to represent what would have been created. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/index.rst0000644000175100001730000000235314467657412022372 0ustar00runnerdocker.. _distutils-index: ############################################## Distributing Python Modules (Legacy version) ############################################## :Authors: Greg Ward, Anthony Baxter :Email: distutils-sig@python.org .. seealso:: :ref:`distributing-index` The up to date module distribution documentations .. include:: ./_setuptools_disclaimer.rst .. note:: This guide only covers the basic tools for building and distributing extensions that are provided as part of this version of Python. Third party tools offer easier to use and more secure alternatives. Refer to the `quick recommendations section `__ in the Python Packaging User Guide for more information. This document describes the Python Distribution Utilities ("Distutils") from the module developer's point of view, describing the underlying capabilities that ``setuptools`` builds on to allow Python developers to make Python modules and extensions readily available to a wider audience. .. toctree:: :maxdepth: 2 :numbered: introduction.rst setupscript.rst configfile.rst sourcedist.rst builtdist.rst examples.rst extending.rst commandref.rst apiref.rst ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/introduction.rst0000644000175100001730000001760614467657412024013 0ustar00runnerdocker.. _distutils-intro: **************************** An Introduction to Distutils **************************** .. include:: ./_setuptools_disclaimer.rst This document covers using the Distutils to distribute your Python modules, concentrating on the role of developer/distributor: if you're looking for information on installing Python modules, you should refer to the :ref:`install-index` chapter. .. _distutils-concepts: Concepts & Terminology ====================== Using the Distutils is quite simple, both for module developers and for users/administrators installing third-party modules. As a developer, your responsibilities (apart from writing solid, well-documented and well-tested code, of course!) are: * write a setup script (:file:`setup.py` by convention) * (optional) write a setup configuration file * create a source distribution * (optional) create one or more built (binary) distributions Each of these tasks is covered in this document. Not all module developers have access to a multitude of platforms, so it's not always feasible to expect them to create a multitude of built distributions. It is hoped that a class of intermediaries, called *packagers*, will arise to address this need. Packagers will take source distributions released by module developers, build them on one or more platforms, and release the resulting built distributions. Thus, users on the most popular platforms will be able to install most popular Python module distributions in the most natural way for their platform, without having to run a single setup script or compile a line of code. .. _distutils-simple-example: A Simple Example ================ The setup script is usually quite simple, although since it's written in Python, there are no arbitrary limits to what you can do with it, though you should be careful about putting arbitrarily expensive operations in your setup script. Unlike, say, Autoconf-style configure scripts, the setup script may be run multiple times in the course of building and installing your module distribution. If all you want to do is distribute a module called ``foo``, contained in a file :file:`foo.py`, then your setup script can be as simple as this:: from distutils.core import setup setup(name='foo', version='1.0', py_modules=['foo'], ) Some observations: * most information that you supply to the Distutils is supplied as keyword arguments to the :func:`~distutils.core.setup` function * those keyword arguments fall into two categories: package metadata (name, version number) and information about what's in the package (a list of pure Python modules, in this case) * modules are specified by module name, not filename (the same will hold true for packages and extensions) * it's recommended that you supply a little more metadata, in particular your name, email address and a URL for the project (see section :ref:`setup-script` for an example) To create a source distribution for this module, you would create a setup script, :file:`setup.py`, containing the above code, and run this command from a terminal:: python setup.py sdist For Windows, open a command prompt window (:menuselection:`Start --> Accessories`) and change the command to:: setup.py sdist :command:`sdist` will create an archive file (e.g., tarball on Unix, ZIP file on Windows) containing your setup script :file:`setup.py`, and your module :file:`foo.py`. The archive file will be named :file:`foo-1.0.tar.gz` (or :file:`.zip`), and will unpack into a directory :file:`foo-1.0`. If an end-user wishes to install your ``foo`` module, all they have to do is download :file:`foo-1.0.tar.gz` (or :file:`.zip`), unpack it, and---from the :file:`foo-1.0` directory---run :: python setup.py install which will ultimately copy :file:`foo.py` to the appropriate directory for third-party modules in their Python installation. This simple example demonstrates some fundamental concepts of the Distutils. First, both developers and installers have the same basic user interface, i.e. the setup script. The difference is which Distutils *commands* they use: the :command:`sdist` command is almost exclusively for module developers, while :command:`install` is more often for installers (although most developers will want to install their own code occasionally). Other useful built distribution formats are RPM, implemented by the :command:`bdist_rpm` command, Solaris :program:`pkgtool` (:command:`bdist_pkgtool`), and HP-UX :program:`swinstall` (:command:`bdist_sdux`). For example, the following command will create an RPM file called :file:`foo-1.0.noarch.rpm`:: python setup.py bdist_rpm (The :command:`bdist_rpm` command uses the :command:`rpm` executable, therefore this has to be run on an RPM-based system such as Red Hat Linux, SuSE Linux, or Mandrake Linux.) You can find out what distribution formats are available at any time by running :: python setup.py bdist --help-formats .. _python-terms: General Python terminology ========================== If you're reading this document, you probably have a good idea of what modules, extensions, and so forth are. Nevertheless, just to be sure that everyone is operating from a common starting point, we offer the following glossary of common Python terms: module the basic unit of code reusability in Python: a block of code imported by some other code. Three types of modules concern us here: pure Python modules, extension modules, and packages. pure Python module a module written in Python and contained in a single :file:`.py` file (and possibly associated :file:`.pyc` files). Sometimes referred to as a "pure module." extension module a module written in the low-level language of the Python implementation: C/C++ for Python, Java for Jython. Typically contained in a single dynamically loadable pre-compiled file, e.g. a shared object (:file:`.so`) file for Python extensions on Unix, a DLL (given the :file:`.pyd` extension) for Python extensions on Windows, or a Java class file for Jython extensions. (Note that currently, the Distutils only handles C/C++ extensions for Python.) package a module that contains other modules; typically contained in a directory in the filesystem and distinguished from other directories by the presence of a file :file:`__init__.py`. root package the root of the hierarchy of packages. (This isn't really a package, since it doesn't have an :file:`__init__.py` file. But we have to call it something.) The vast majority of the standard library is in the root package, as are many small, standalone third-party modules that don't belong to a larger module collection. Unlike regular packages, modules in the root package can be found in many directories: in fact, every directory listed in ``sys.path`` contributes modules to the root package. .. _distutils-term: Distutils-specific terminology ============================== The following terms apply more specifically to the domain of distributing Python modules using the Distutils: module distribution a collection of Python modules distributed together as a single downloadable resource and meant to be installed *en masse*. Examples of some well-known module distributions are NumPy, SciPy, Pillow, or mxBase. (This would be called a *package*, except that term is already taken in the Python context: a single module distribution may contain zero, one, or many Python packages.) pure module distribution a module distribution that contains only pure Python modules and packages. Sometimes referred to as a "pure distribution." non-pure module distribution a module distribution that contains at least one extension module. Sometimes referred to as a "non-pure distribution." distribution root the top-level directory of your source tree (or source distribution); the directory where :file:`setup.py` exists. Generally :file:`setup.py` will be run from this directory. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/packageindex.rst0000644000175100001730000000070014467657412023700 0ustar00runnerdocker:orphan: .. _package-index: ******************************* The Python Package Index (PyPI) ******************************* The `Python Package Index (PyPI)`_ stores metadata describing distributions packaged with distutils and other publishing tools, as well the distribution archives themselves. References to up to date PyPI documentation can be found at :ref:`publishing-python-packages`. .. _Python Package Index (PyPI): https://pypi.org ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/setupscript.rst0000644000175100001730000007514614467657412023662 0ustar00runnerdocker.. _setup-script: ************************ Writing the Setup Script ************************ .. include:: ./_setuptools_disclaimer.rst The setup script is the centre of all activity in building, distributing, and installing modules using the Distutils. The main purpose of the setup script is to describe your module distribution to the Distutils, so that the various commands that operate on your modules do the right thing. As we saw in section :ref:`distutils-simple-example` above, the setup script consists mainly of a call to :func:`~distutils.core.setup`, and most information supplied to the Distutils by the module developer is supplied as keyword arguments to :func:`~distutils.core.setup`. Here's a slightly more involved example, which we'll follow for the next couple of sections: the Distutils' own setup script. (Keep in mind that although the Distutils are included with Python 1.6 and later, they also have an independent existence so that Python 1.5.2 users can use them to install other module distributions. The Distutils' own setup script, shown here, is used to install the package into Python 1.5.2.) :: #!/usr/bin/env python from distutils.core import setup setup(name='Distutils', version='1.0', description='Python Distribution Utilities', author='Greg Ward', author_email='gward@python.net', url='https://www.python.org/sigs/distutils-sig/', packages=['distutils', 'distutils.command'], ) There are only two differences between this and the trivial one-file distribution presented in section :ref:`distutils-simple-example`: more metadata, and the specification of pure Python modules by package, rather than by module. This is important since the Distutils consist of a couple of dozen modules split into (so far) two packages; an explicit list of every module would be tedious to generate and difficult to maintain. For more information on the additional meta-data, see section :ref:`meta-data`. Note that any pathnames (files or directories) supplied in the setup script should be written using the Unix convention, i.e. slash-separated. The Distutils will take care of converting this platform-neutral representation into whatever is appropriate on your current platform before actually using the pathname. This makes your setup script portable across operating systems, which of course is one of the major goals of the Distutils. In this spirit, all pathnames in this document are slash-separated. This, of course, only applies to pathnames given to Distutils functions. If you, for example, use standard Python functions such as :func:`glob.glob` or :func:`os.listdir` to specify files, you should be careful to write portable code instead of hardcoding path separators:: glob.glob(os.path.join('mydir', 'subdir', '*.html')) os.listdir(os.path.join('mydir', 'subdir')) .. _listing-packages: Listing whole packages ====================== The ``packages`` option tells the Distutils to process (build, distribute, install, etc.) all pure Python modules found in each package mentioned in the ``packages`` list. In order to do this, of course, there has to be a correspondence between package names and directories in the filesystem. The default correspondence is the most obvious one, i.e. package :mod:`distutils` is found in the directory :file:`distutils` relative to the distribution root. Thus, when you say ``packages = ['foo']`` in your setup script, you are promising that the Distutils will find a file :file:`foo/__init__.py` (which might be spelled differently on your system, but you get the idea) relative to the directory where your setup script lives. If you break this promise, the Distutils will issue a warning but still process the broken package anyway. If you use a different convention to lay out your source directory, that's no problem: you just have to supply the ``package_dir`` option to tell the Distutils about your convention. For example, say you keep all Python source under :file:`lib`, so that modules in the "root package" (i.e., not in any package at all) are in :file:`lib`, modules in the ``foo`` package are in :file:`lib/foo`, and so forth. Then you would put :: package_dir = {'': 'lib'} in your setup script. The keys to this dictionary are package names, and an empty package name stands for the root package. The values are directory names relative to your distribution root. In this case, when you say ``packages = ['foo']``, you are promising that the file :file:`lib/foo/__init__.py` exists. Another possible convention is to put the ``foo`` package right in :file:`lib`, the ``foo.bar`` package in :file:`lib/bar`, etc. This would be written in the setup script as :: package_dir = {'foo': 'lib'} A ``package: dir`` entry in the ``package_dir`` dictionary implicitly applies to all packages below *package*, so the ``foo.bar`` case is automatically handled here. In this example, having ``packages = ['foo', 'foo.bar']`` tells the Distutils to look for :file:`lib/__init__.py` and :file:`lib/bar/__init__.py`. (Keep in mind that although ``package_dir`` applies recursively, you must explicitly list all packages in ``packages``: the Distutils will *not* recursively scan your source tree looking for any directory with an :file:`__init__.py` file.) .. _listing-modules: Listing individual modules ========================== For a small module distribution, you might prefer to list all modules rather than listing packages---especially the case of a single module that goes in the "root package" (i.e., no package at all). This simplest case was shown in section :ref:`distutils-simple-example`; here is a slightly more involved example:: py_modules = ['mod1', 'pkg.mod2'] This describes two modules, one of them in the "root" package, the other in the ``pkg`` package. Again, the default package/directory layout implies that these two modules can be found in :file:`mod1.py` and :file:`pkg/mod2.py`, and that :file:`pkg/__init__.py` exists as well. And again, you can override the package/directory correspondence using the ``package_dir`` option. .. _describing-extensions: Describing extension modules ============================ Just as writing Python extension modules is a bit more complicated than writing pure Python modules, describing them to the Distutils is a bit more complicated. Unlike pure modules, it's not enough just to list modules or packages and expect the Distutils to go out and find the right files; you have to specify the extension name, source file(s), and any compile/link requirements (include directories, libraries to link with, etc.). .. XXX read over this section All of this is done through another keyword argument to :func:`~distutils.core.setup`, the ``ext_modules`` option. ``ext_modules`` is just a list of :class:`~distutils.core.Extension` instances, each of which describes a single extension module. Suppose your distribution includes a single extension, called ``foo`` and implemented by :file:`foo.c`. If no additional instructions to the compiler/linker are needed, describing this extension is quite simple:: Extension('foo', ['foo.c']) The :class:`~distutils.extension.Extension` class can be imported from :mod:`distutils.core` along with :func:`~distutils.core.setup`. Thus, the setup script for a module distribution that contains only this one extension and nothing else might be:: from distutils.core import setup, Extension setup(name='foo', version='1.0', ext_modules=[Extension('foo', ['foo.c'])], ) The :class:`~distutils.extension.Extension` class (actually, the underlying extension-building machinery implemented by the :command:`build_ext` command) supports a great deal of flexibility in describing Python extensions, which is explained in the following sections. Extension names and packages ---------------------------- The first argument to the :class:`~distutils.core.Extension` constructor is always the name of the extension, including any package names. For example, :: Extension('foo', ['src/foo1.c', 'src/foo2.c']) describes an extension that lives in the root package, while :: Extension('pkg.foo', ['src/foo1.c', 'src/foo2.c']) describes the same extension in the ``pkg`` package. The source files and resulting object code are identical in both cases; the only difference is where in the filesystem (and therefore where in Python's namespace hierarchy) the resulting extension lives. If you have a number of extensions all in the same package (or all under the same base package), use the ``ext_package`` keyword argument to :func:`~distutils.core.setup`. For example, :: setup(..., ext_package='pkg', ext_modules=[Extension('foo', ['foo.c']), Extension('subpkg.bar', ['bar.c'])], ) will compile :file:`foo.c` to the extension ``pkg.foo``, and :file:`bar.c` to ``pkg.subpkg.bar``. Extension source files ---------------------- The second argument to the :class:`~distutils.core.Extension` constructor is a list of source files. Since the Distutils currently only support C, C++, and Objective-C extensions, these are normally C/C++/Objective-C source files. (Be sure to use appropriate extensions to distinguish C++ source files: :file:`.cc` and :file:`.cpp` seem to be recognized by both Unix and Windows compilers.) However, you can also include SWIG interface (:file:`.i`) files in the list; the :command:`build_ext` command knows how to deal with SWIG extensions: it will run SWIG on the interface file and compile the resulting C/C++ file into your extension. .. XXX SWIG support is rough around the edges and largely untested! This warning notwithstanding, options to SWIG can be currently passed like this:: setup(..., ext_modules=[Extension('_foo', ['foo.i'], swig_opts=['-modern', '-I../include'])], py_modules=['foo'], ) Or on the commandline like this:: > python setup.py build_ext --swig-opts="-modern -I../include" On some platforms, you can include non-source files that are processed by the compiler and included in your extension. Currently, this just means Windows message text (:file:`.mc`) files and resource definition (:file:`.rc`) files for Visual C++. These will be compiled to binary resource (:file:`.res`) files and linked into the executable. Preprocessor options -------------------- Three optional arguments to :class:`~distutils.core.Extension` will help if you need to specify include directories to search or preprocessor macros to define/undefine: ``include_dirs``, ``define_macros``, and ``undef_macros``. For example, if your extension requires header files in the :file:`include` directory under your distribution root, use the ``include_dirs`` option:: Extension('foo', ['foo.c'], include_dirs=['include']) You can specify absolute directories there; if you know that your extension will only be built on Unix systems with X11R6 installed to :file:`/usr`, you can get away with :: Extension('foo', ['foo.c'], include_dirs=['/usr/include/X11']) You should avoid this sort of non-portable usage if you plan to distribute your code: it's probably better to write C code like :: #include If you need to include header files from some other Python extension, you can take advantage of the fact that header files are installed in a consistent way by the Distutils :command:`install_headers` command. For example, the Numerical Python header files are installed (on a standard Unix installation) to :file:`/usr/local/include/python1.5/Numerical`. (The exact location will differ according to your platform and Python installation.) Since the Python include directory---\ :file:`/usr/local/include/python1.5` in this case---is always included in the search path when building Python extensions, the best approach is to write C code like :: #include If you must put the :file:`Numerical` include directory right into your header search path, though, you can find that directory using the Distutils :mod:`distutils.sysconfig` module:: from distutils.sysconfig import get_python_inc incdir = os.path.join(get_python_inc(plat_specific=1), 'Numerical') setup(..., Extension(..., include_dirs=[incdir]), ) Even though this is quite portable---it will work on any Python installation, regardless of platform---it's probably easier to just write your C code in the sensible way. You can define and undefine pre-processor macros with the ``define_macros`` and ``undef_macros`` options. ``define_macros`` takes a list of ``(name, value)`` tuples, where ``name`` is the name of the macro to define (a string) and ``value`` is its value: either a string or ``None``. (Defining a macro ``FOO`` to ``None`` is the equivalent of a bare ``#define FOO`` in your C source: with most compilers, this sets ``FOO`` to the string ``1``.) ``undef_macros`` is just a list of macros to undefine. For example:: Extension(..., define_macros=[('NDEBUG', '1'), ('HAVE_STRFTIME', None)], undef_macros=['HAVE_FOO', 'HAVE_BAR']) is the equivalent of having this at the top of every C source file:: #define NDEBUG 1 #define HAVE_STRFTIME #undef HAVE_FOO #undef HAVE_BAR Library options --------------- You can also specify the libraries to link against when building your extension, and the directories to search for those libraries. The ``libraries`` option is a list of libraries to link against, ``library_dirs`` is a list of directories to search for libraries at link-time, and ``runtime_library_dirs`` is a list of directories to search for shared (dynamically loaded) libraries at run-time. For example, if you need to link against libraries known to be in the standard library search path on target systems :: Extension(..., libraries=['gdbm', 'readline']) If you need to link with libraries in a non-standard location, you'll have to include the location in ``library_dirs``:: Extension(..., library_dirs=['/usr/X11R6/lib'], libraries=['X11', 'Xt']) (Again, this sort of non-portable construct should be avoided if you intend to distribute your code.) .. XXX Should mention clib libraries here or somewhere else! Other options ------------- There are still some other options which can be used to handle special cases. The ``optional`` option is a boolean; if it is true, a build failure in the extension will not abort the build process, but instead simply not install the failing extension. The ``extra_objects`` option is a list of object files to be passed to the linker. These files must not have extensions, as the default extension for the compiler is used. ``extra_compile_args`` and ``extra_link_args`` can be used to specify additional command line options for the respective compiler and linker command lines. ``export_symbols`` is only useful on Windows. It can contain a list of symbols (functions or variables) to be exported. This option is not needed when building compiled extensions: Distutils will automatically add ``initmodule`` to the list of exported symbols. The ``depends`` option is a list of files that the extension depends on (for example header files). The build command will call the compiler on the sources to rebuild extension if any on this files has been modified since the previous build. Relationships between Distributions and Packages ================================================ A distribution may relate to packages in three specific ways: #. It can require packages or modules. #. It can provide packages or modules. #. It can obsolete packages or modules. These relationships can be specified using keyword arguments to the :func:`distutils.core.setup` function. Dependencies on other Python modules and packages can be specified by supplying the *requires* keyword argument to :func:`~distutils.core.setup`. The value must be a list of strings. Each string specifies a package that is required, and optionally what versions are sufficient. To specify that any version of a module or package is required, the string should consist entirely of the module or package name. Examples include ``'mymodule'`` and ``'xml.parsers.expat'``. If specific versions are required, a sequence of qualifiers can be supplied in parentheses. Each qualifier may consist of a comparison operator and a version number. The accepted comparison operators are:: < > == <= >= != These can be combined by using multiple qualifiers separated by commas (and optional whitespace). In this case, all of the qualifiers must be matched; a logical AND is used to combine the evaluations. Let's look at a bunch of examples: +-------------------------+----------------------------------------------+ | Requires Expression | Explanation | +=========================+==============================================+ | ``==1.0`` | Only version ``1.0`` is compatible | +-------------------------+----------------------------------------------+ | ``>1.0, !=1.5.1, <2.0`` | Any version after ``1.0`` and before ``2.0`` | | | is compatible, except ``1.5.1`` | +-------------------------+----------------------------------------------+ Now that we can specify dependencies, we also need to be able to specify what we provide that other distributions can require. This is done using the *provides* keyword argument to :func:`~distutils.core.setup`. The value for this keyword is a list of strings, each of which names a Python module or package, and optionally identifies the version. If the version is not specified, it is assumed to match that of the distribution. Some examples: +---------------------+----------------------------------------------+ | Provides Expression | Explanation | +=====================+==============================================+ | ``mypkg`` | Provide ``mypkg``, using the distribution | | | version | +---------------------+----------------------------------------------+ | ``mypkg (1.1)`` | Provide ``mypkg`` version 1.1, regardless of | | | the distribution version | +---------------------+----------------------------------------------+ A package can declare that it obsoletes other packages using the *obsoletes* keyword argument. The value for this is similar to that of the *requires* keyword: a list of strings giving module or package specifiers. Each specifier consists of a module or package name optionally followed by one or more version qualifiers. Version qualifiers are given in parentheses after the module or package name. The versions identified by the qualifiers are those that are obsoleted by the distribution being described. If no qualifiers are given, all versions of the named module or package are understood to be obsoleted. .. _distutils-installing-scripts: Installing Scripts ================== So far we have been dealing with pure and non-pure Python modules, which are usually not run by themselves but imported by scripts. Scripts are files containing Python source code, intended to be started from the command line. Scripts don't require Distutils to do anything very complicated. The only clever feature is that if the first line of the script starts with ``#!`` and contains the word "python", the Distutils will adjust the first line to refer to the current interpreter location. By default, it is replaced with the current interpreter location. The :option:`!--executable` (or :option:`!-e`) option will allow the interpreter path to be explicitly overridden. The ``scripts`` option simply is a list of files to be handled in this way. From the PyXML setup script:: setup(..., scripts=['scripts/xmlproc_parse', 'scripts/xmlproc_val'] ) .. versionchanged:: 3.1 All the scripts will also be added to the ``MANIFEST`` file if no template is provided. See :ref:`manifest`. .. _distutils-installing-package-data: Installing Package Data ======================= Often, additional files need to be installed into a package. These files are often data that's closely related to the package's implementation, or text files containing documentation that might be of interest to programmers using the package. These files are called :dfn:`package data`. Package data can be added to packages using the ``package_data`` keyword argument to the :func:`~distutils.core.setup` function. The value must be a mapping from package name to a list of relative path names that should be copied into the package. The paths are interpreted as relative to the directory containing the package (information from the ``package_dir`` mapping is used if appropriate); that is, the files are expected to be part of the package in the source directories. They may contain glob patterns as well. The path names may contain directory portions; any necessary directories will be created in the installation. For example, if a package should contain a subdirectory with several data files, the files can be arranged like this in the source tree:: setup.py src/ mypkg/ __init__.py module.py data/ tables.dat spoons.dat forks.dat The corresponding call to :func:`~distutils.core.setup` might be:: setup(..., packages=['mypkg'], package_dir={'mypkg': 'src/mypkg'}, package_data={'mypkg': ['data/*.dat']}, ) .. versionchanged:: 3.1 All the files that match ``package_data`` will be added to the ``MANIFEST`` file if no template is provided. See :ref:`manifest`. .. _distutils-additional-files: Installing Additional Files =========================== The ``data_files`` option can be used to specify additional files needed by the module distribution: configuration files, message catalogs, data files, anything which doesn't fit in the previous categories. ``data_files`` specifies a sequence of (*directory*, *files*) pairs in the following way:: setup(..., data_files=[('bitmaps', ['bm/b1.gif', 'bm/b2.gif']), ('config', ['cfg/data.cfg'])], ) Each (*directory*, *files*) pair in the sequence specifies the installation directory and the files to install there. Each file name in *files* is interpreted relative to the :file:`setup.py` script at the top of the package source distribution. Note that you can specify the directory where the data files will be installed, but you cannot rename the data files themselves. The *directory* should be a relative path. It is interpreted relative to the installation prefix (Python's ``sys.prefix`` for system installations; ``site.USER_BASE`` for user installations). Distutils allows *directory* to be an absolute installation path, but this is discouraged since it is incompatible with the wheel packaging format. No directory information from *files* is used to determine the final location of the installed file; only the name of the file is used. You can specify the ``data_files`` options as a simple sequence of files without specifying a target directory, but this is not recommended, and the :command:`install` command will print a warning in this case. To install data files directly in the target directory, an empty string should be given as the directory. .. versionchanged:: 3.1 All the files that match ``data_files`` will be added to the ``MANIFEST`` file if no template is provided. See :ref:`manifest`. .. _meta-data: Additional meta-data ==================== The setup script may include additional meta-data beyond the name and version. This information includes: +----------------------+---------------------------+-----------------+--------+ | Meta-Data | Description | Value | Notes | +======================+===========================+=================+========+ | ``name`` | name of the package | short string | \(1) | +----------------------+---------------------------+-----------------+--------+ | ``version`` | version of this release | short string | (1)(2) | +----------------------+---------------------------+-----------------+--------+ | ``author`` | package author's name | short string | \(3) | +----------------------+---------------------------+-----------------+--------+ | ``author_email`` | email address of the | email address | \(3) | | | package author | | | +----------------------+---------------------------+-----------------+--------+ | ``maintainer`` | package maintainer's name | short string | \(3) | +----------------------+---------------------------+-----------------+--------+ | ``maintainer_email`` | email address of the | email address | \(3) | | | package maintainer | | | +----------------------+---------------------------+-----------------+--------+ | ``url`` | home page for the package | URL | | +----------------------+---------------------------+-----------------+--------+ | ``description`` | short, summary | short string | | | | description of the | | | | | package | | | +----------------------+---------------------------+-----------------+--------+ | ``long_description`` | longer description of the | long string | \(4) | | | package | | | +----------------------+---------------------------+-----------------+--------+ | ``download_url`` | location where the | URL | | | | package may be downloaded | | | +----------------------+---------------------------+-----------------+--------+ | ``classifiers`` | a list of classifiers | list of strings | (6)(7) | +----------------------+---------------------------+-----------------+--------+ | ``platforms`` | a list of platforms | list of strings | (6)(8) | +----------------------+---------------------------+-----------------+--------+ | ``keywords`` | a list of keywords | list of strings | (6)(8) | +----------------------+---------------------------+-----------------+--------+ | ``license`` | license for the package | short string | \(5) | +----------------------+---------------------------+-----------------+--------+ Notes: (1) These fields are required. (2) It is recommended that versions take the form *major.minor[.patch[.sub]]*. (3) If maintainer is provided and author is not, distutils lists maintainer as the author in :file:`PKG-INFO`. (4) The ``long_description`` field is used by PyPI when you publish a package, to build its project page. (5) The ``license`` field is a text indicating the license covering the package where the license is not a selection from the "License" Trove classifiers. See the ``Classifier`` field. Notice that there's a ``licence`` distribution option which is deprecated but still acts as an alias for ``license``. (6) This field must be a list. (7) The valid classifiers are listed on `PyPI `_. (8) To preserve backward compatibility, this field also accepts a string. If you pass a comma-separated string ``'foo, bar'``, it will be converted to ``['foo', 'bar']``, Otherwise, it will be converted to a list of one string. 'short string' A single line of text, not more than 200 characters. 'long string' Multiple lines of plain text in reStructuredText format (see http://docutils.sourceforge.net/). 'list of strings' See below. Encoding the version information is an art in itself. Python packages generally adhere to the version format *major.minor[.patch][sub]*. The major number is 0 for initial, experimental releases of software. It is incremented for releases that represent major milestones in a package. The minor number is incremented when important new features are added to the package. The patch number increments when bug-fix releases are made. Additional trailing version information is sometimes used to indicate sub-releases. These are "a1,a2,...,aN" (for alpha releases, where functionality and API may change), "b1,b2,...,bN" (for beta releases, which only fix bugs) and "pr1,pr2,...,prN" (for final pre-release release testing). Some examples: 0.1.0 the first, experimental release of a package 1.0.1a2 the second alpha release of the first patch version of 1.0 ``classifiers`` must be specified in a list:: setup(..., classifiers=[ 'Development Status :: 4 - Beta', 'Environment :: Console', 'Environment :: Web Environment', 'Intended Audience :: End Users/Desktop', 'Intended Audience :: Developers', 'Intended Audience :: System Administrators', 'License :: OSI Approved :: Python Software Foundation License', 'Operating System :: MacOS :: MacOS X', 'Operating System :: Microsoft :: Windows', 'Operating System :: POSIX', 'Programming Language :: Python', 'Topic :: Communications :: Email', 'Topic :: Office/Business', 'Topic :: Software Development :: Bug Tracking', ], ) .. versionchanged:: 3.7 :class:`~distutils.core.setup` now warns when ``classifiers``, ``keywords`` or ``platforms`` fields are not specified as a list or a string. .. _debug-setup-script: Debugging the setup script ========================== Sometimes things go wrong, and the setup script doesn't do what the developer wants. Distutils catches any exceptions when running the setup script, and print a simple error message before the script is terminated. The motivation for this behaviour is to not confuse administrators who don't know much about Python and are trying to install a package. If they get a big long traceback from deep inside the guts of Distutils, they may think the package or the Python installation is broken because they don't read all the way down to the bottom and see that it's a permission problem. On the other hand, this doesn't help the developer to find the cause of the failure. For this purpose, the :envvar:`DISTUTILS_DEBUG` environment variable can be set to anything except an empty string, and distutils will now print detailed information about what it is doing, dump the full traceback when an exception occurs, and print the whole command line when an external program (like a C compiler) fails. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/sourcedist.rst0000644000175100001730000002301514467657412023445 0ustar00runnerdocker.. _source-dist: ****************************** Creating a Source Distribution ****************************** .. include:: ./_setuptools_disclaimer.rst As shown in section :ref:`distutils-simple-example`, you use the :command:`sdist` command to create a source distribution. In the simplest case, :: python setup.py sdist (assuming you haven't specified any :command:`sdist` options in the setup script or config file), :command:`sdist` creates the archive of the default format for the current platform. The default format is a gzip'ed tar file (:file:`.tar.gz`) on Unix, and ZIP file on Windows. You can specify as many formats as you like using the :option:`!--formats` option, for example:: python setup.py sdist --formats=gztar,zip to create a gzipped tarball and a zip file. The available formats are: +-----------+-------------------------+---------+ | Format | Description | Notes | +===========+=========================+=========+ | ``zip`` | zip file (:file:`.zip`) | (1),(3) | +-----------+-------------------------+---------+ | ``gztar`` | gzip'ed tar file | \(2) | | | (:file:`.tar.gz`) | | +-----------+-------------------------+---------+ | ``bztar`` | bzip2'ed tar file | | | | (:file:`.tar.bz2`) | | +-----------+-------------------------+---------+ | ``xztar`` | xz'ed tar file | | | | (:file:`.tar.xz`) | | +-----------+-------------------------+---------+ | ``ztar`` | compressed tar file | \(4) | | | (:file:`.tar.Z`) | | +-----------+-------------------------+---------+ | ``tar`` | tar file (:file:`.tar`) | | +-----------+-------------------------+---------+ .. versionchanged:: 3.5 Added support for the ``xztar`` format. Notes: (1) default on Windows (2) default on Unix (3) requires either external :program:`zip` utility or :mod:`zipfile` module (part of the standard Python library since Python 1.6) (4) requires the :program:`compress` program. Notice that this format is now pending for deprecation and will be removed in the future versions of Python. When using any ``tar`` format (``gztar``, ``bztar``, ``xztar``, ``ztar`` or ``tar``), under Unix you can specify the ``owner`` and ``group`` names that will be set for each member of the archive. For example, if you want all files of the archive to be owned by root:: python setup.py sdist --owner=root --group=root .. _manifest: Specifying the files to distribute ================================== If you don't supply an explicit list of files (or instructions on how to generate one), the :command:`sdist` command puts a minimal default set into the source distribution: * all Python source files implied by the ``py_modules`` and ``packages`` options * all C source files mentioned in the ``ext_modules`` or ``libraries`` options .. XXX getting C library sources currently broken---no :meth:`get_source_files` method in :file:`build_clib.py`! * scripts identified by the ``scripts`` option See :ref:`distutils-installing-scripts`. * anything that looks like a test script: :file:`test/test\*.py` (currently, the Distutils don't do anything with test scripts except include them in source distributions, but in the future there will be a standard for testing Python module distributions) * Any of the standard README files (:file:`README`, :file:`README.txt`, or :file:`README.rst`), :file:`setup.py` (or whatever you called your setup script), and :file:`setup.cfg`. * all files that matches the ``package_data`` metadata. See :ref:`distutils-installing-package-data`. * all files that matches the ``data_files`` metadata. See :ref:`distutils-additional-files`. Sometimes this is enough, but usually you will want to specify additional files to distribute. The typical way to do this is to write a *manifest template*, called :file:`MANIFEST.in` by default. The manifest template is just a list of instructions for how to generate your manifest file, :file:`MANIFEST`, which is the exact list of files to include in your source distribution. The :command:`sdist` command processes this template and generates a manifest based on its instructions and what it finds in the filesystem. If you prefer to roll your own manifest file, the format is simple: one filename per line, regular files (or symlinks to them) only. If you do supply your own :file:`MANIFEST`, you must specify everything: the default set of files described above does not apply in this case. .. versionchanged:: 3.1 An existing generated :file:`MANIFEST` will be regenerated without :command:`sdist` comparing its modification time to the one of :file:`MANIFEST.in` or :file:`setup.py`. .. versionchanged:: 3.1.3 :file:`MANIFEST` files start with a comment indicating they are generated. Files without this comment are not overwritten or removed. .. versionchanged:: 3.2.2 :command:`sdist` will read a :file:`MANIFEST` file if no :file:`MANIFEST.in` exists, like it used to do. .. versionchanged:: 3.7 :file:`README.rst` is now included in the list of distutils standard READMEs. The manifest template has one command per line, where each command specifies a set of files to include or exclude from the source distribution. For an example, again we turn to the Distutils' own manifest template: .. code-block:: none include *.txt recursive-include examples *.txt *.py prune examples/sample?/build The meanings should be fairly clear: include all files in the distribution root matching :file:`\*.txt`, all files anywhere under the :file:`examples` directory matching :file:`\*.txt` or :file:`\*.py`, and exclude all directories matching :file:`examples/sample?/build`. All of this is done *after* the standard include set, so you can exclude files from the standard set with explicit instructions in the manifest template. (Or, you can use the :option:`!--no-defaults` option to disable the standard set entirely.) There are several other commands available in the manifest template mini-language; see section :ref:`sdist-cmd`. The order of commands in the manifest template matters: initially, we have the list of default files as described above, and each command in the template adds to or removes from that list of files. Once we have fully processed the manifest template, we remove files that should not be included in the source distribution: * all files in the Distutils "build" tree (default :file:`build/`) * all files in directories named :file:`RCS`, :file:`CVS`, :file:`.svn`, :file:`.hg`, :file:`.git`, :file:`.bzr` or :file:`_darcs` Now we have our complete list of files, which is written to the manifest for future reference, and then used to build the source distribution archive(s). You can disable the default set of included files with the :option:`!--no-defaults` option, and you can disable the standard exclude set with :option:`!--no-prune`. Following the Distutils' own manifest template, let's trace how the :command:`sdist` command builds the list of files to include in the Distutils source distribution: #. include all Python source files in the :file:`distutils` and :file:`distutils/command` subdirectories (because packages corresponding to those two directories were mentioned in the ``packages`` option in the setup script---see section :ref:`setup-script`) #. include :file:`README.txt`, :file:`setup.py`, and :file:`setup.cfg` (standard files) #. include :file:`test/test\*.py` (standard files) #. include :file:`\*.txt` in the distribution root (this will find :file:`README.txt` a second time, but such redundancies are weeded out later) #. include anything matching :file:`\*.txt` or :file:`\*.py` in the sub-tree under :file:`examples`, #. exclude all files in the sub-trees starting at directories matching :file:`examples/sample?/build`\ ---this may exclude files included by the previous two steps, so it's important that the ``prune`` command in the manifest template comes after the ``recursive-include`` command #. exclude the entire :file:`build` tree, and any :file:`RCS`, :file:`CVS`, :file:`.svn`, :file:`.hg`, :file:`.git`, :file:`.bzr` and :file:`_darcs` directories Just like in the setup script, file and directory names in the manifest template should always be slash-separated; the Distutils will take care of converting them to the standard representation on your platform. That way, the manifest template is portable across operating systems. .. _manifest-options: Manifest-related options ======================== The normal course of operations for the :command:`sdist` command is as follows: * if the manifest file (:file:`MANIFEST` by default) exists and the first line does not have a comment indicating it is generated from :file:`MANIFEST.in`, then it is used as is, unaltered * if the manifest file doesn't exist or has been previously automatically generated, read :file:`MANIFEST.in` and create the manifest * if neither :file:`MANIFEST` nor :file:`MANIFEST.in` exist, create a manifest with just the default file set * use the list of files now in :file:`MANIFEST` (either just generated or read in) to create the source distribution archive(s) There are a couple of options that modify this behaviour. First, use the :option:`!--no-defaults` and :option:`!--no-prune` to disable the standard "include" and "exclude" sets. Second, you might just want to (re)generate the manifest, but not create a source distribution:: python setup.py sdist --manifest-only :option:`!-o` is a shortcut for :option:`!--manifest-only`. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils/uploading.rst0000644000175100001730000000034214467657412023241 0ustar00runnerdocker:orphan: *************************************** Uploading Packages to the Package Index *************************************** References to up to date PyPI documentation can be found at :ref:`publishing-python-packages`. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/distutils-legacy.rst0000644000175100001730000000451514467657412022527 0ustar00runnerdockerPorting from Distutils ====================== Setuptools and the PyPA have a `stated goal `_ to make Setuptools the reference API for distutils. Since the 60.0.0 release, Setuptools includes a local, vendored copy of distutils (from late copies of CPython) that is enabled by default. To disable the use of this copy of distutils when invoking setuptools, set the environment variable: SETUPTOOLS_USE_DISTUTILS=stdlib .. warning:: Please note that this also affects how ``distutils.cfg`` files inside stdlib's ``distutils`` package directory are processed. Unless ``SETUPTOOLS_USE_DISTUTILS=stdlib``, they will have no effect on the build process. You can still use a global user config file, ``~/.pydistutils.cfg`` (POSIX) or ``%USERPROFILE%/pydistutils.cfg`` (Windows), or use the environment variable :ref:`DIST_EXTRA_CONFIG ` to point to another supplementary configuration file. Prefer Setuptools ----------------- As Distutils is deprecated, any usage of functions or objects from distutils is similarly discouraged, and Setuptools aims to replace or deprecate all such uses. This section describes the recommended replacements. ``distutils.core.setup`` → ``setuptools.setup`` ``distutils.cmd.Command`` or ``distutils.core.Command`` → ``setuptools.Command`` ``distutils.command.{build_clib,build_ext,build_py,sdist}`` → ``setuptools.command.*`` ``distutils.log`` → :mod:`logging` (standard library) ``distutils.version.*`` → :doc:`packaging.version.* ` ``distutils.errors.*`` → ``setuptools.errors.*`` [#errors]_ Migration advice is also provided by :pep:`PEP 632 <632#migration-advice>`. If a project relies on uses of ``distutils`` that do not have a suitable replacement above, please search the `Setuptools issue tracker `_ and file a request, describing the use-case so that Setuptools' maintainers can investigate. Please provide enough detail to help the maintainers understand how distutils is used, what value it provides, and why that behavior should be supported. .. [#errors] Please notice errors related to the command line usage of ``setup.py``, such as ``DistutilsArgError``, are intentionally not exposed by setuptools, since this is considered a deprecated practice. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/easy_install.rst0000644000175100001730000014545214467657412021736 0ustar00runnerdocker============ Easy Install ============ .. warning:: Easy Install is deprecated. Do not use it. Instead use pip. If you think you need Easy Install, please reach out to the PyPA team (a ticket to pip or setuptools is fine), describing your use-case. Easy Install is a python module (``easy_install``) bundled with ``setuptools`` that lets you automatically download, build, install, and manage Python packages. Please share your experiences with us! If you encounter difficulty installing a package, please contact us via the `distutils mailing list `_. (Note: please DO NOT send private email directly to the author of setuptools; it will be discarded. The mailing list is a searchable archive of previously-asked and answered questions; you should begin your research there before reporting something as a bug -- and then do so via list discussion first.) (Also, if you'd like to learn about how you can use ``setuptools`` to make your own packages work better with EasyInstall, or provide EasyInstall-like features without requiring your users to use EasyInstall directly, you'll probably want to check out the full documentation as well.) Using "Easy Install" ==================== .. _installation instructions: Installing "Easy Install" ------------------------- Please see the :pypi:`setuptools` on the package index for download links and basic installation instructions for each of the supported platforms. You will need at least Python 3.5 or 2.7. An ``easy_install`` script will be installed in the normal location for Python scripts on your platform. Note that the instructions on the setuptools PyPI page assume that you are are installing to Python's primary ``site-packages`` directory. If this is not the case, you should consult the section below on `Custom Installation Locations`_ before installing. (And, on Windows, you should not use the ``.exe`` installer when installing to an alternate location.) Note that ``easy_install`` normally works by downloading files from the internet. If you are behind an NTLM-based firewall that prevents Python programs from accessing the net directly, you may wish to first install and use the `APS proxy server `_, which lets you get past such firewalls in the same way that your web browser(s) do. (Alternately, if you do not wish easy_install to actually download anything, you can restrict it from doing so with the ``--allow-hosts`` option; see the sections on `restricting downloads with --allow-hosts`_ and `command-line options`_ for more details.) Troubleshooting ~~~~~~~~~~~~~~~ If EasyInstall/setuptools appears to install correctly, and you can run the ``easy_install`` command but it fails with an ``ImportError``, the most likely cause is that you installed to a location other than ``site-packages``, without taking any of the steps described in the `Custom Installation Locations`_ section below. Please see that section and follow the steps to make sure that your custom location will work correctly. Then re-install. Similarly, if you can run ``easy_install``, and it appears to be installing packages, but then you can't import them, the most likely issue is that you installed EasyInstall correctly but are using it to install packages to a non-standard location that hasn't been properly prepared. Again, see the section on `Custom Installation Locations`_ for more details. Windows Notes ~~~~~~~~~~~~~ Installing setuptools will provide an ``easy_install`` command according to the techniques described in `Executables and Launchers`_. If the ``easy_install`` command is not available after installation, that section provides details on how to configure Windows to make the commands available. Downloading and Installing a Package ------------------------------------ For basic use of ``easy_install``, you need only supply the filename or URL of a source distribution or .egg file (`Python Egg`__). __ http://peak.telecommunity.com/DevCenter/PythonEggs **Example 1**. Install a package by name, searching PyPI for the latest version, and automatically downloading, building, and installing it:: easy_install SQLObject **Example 2**. Install or upgrade a package by name and version by finding links on a given "download page":: easy_install -f http://pythonpaste.org/package_index.html SQLObject **Example 3**. Download a source distribution from a specified URL, automatically building and installing it:: easy_install http://example.com/path/to/MyPackage-1.2.3.tgz **Example 4**. Install an already-downloaded .egg file:: easy_install /my_downloads/OtherPackage-3.2.1-py2.3.egg **Example 5**. Upgrade an already-installed package to the latest version listed on PyPI:: easy_install --upgrade PyProtocols **Example 6**. Install a source distribution that's already downloaded and extracted in the current directory (New in 0.5a9):: easy_install . **Example 7**. (New in 0.6a1) Find a source distribution or Subversion checkout URL for a package, and extract it or check it out to ``~/projects/sqlobject`` (the name will always be in all-lowercase), where it can be examined or edited. (The package will not be installed, but it can easily be installed with ``easy_install ~/projects/sqlobject``. See `Editing and Viewing Source Packages`_ below for more info.):: easy_install --editable --build-directory ~/projects SQLObject **Example 7**. (New in 0.6.11) Install a distribution within your home dir:: easy_install --user SQLAlchemy Easy Install accepts URLs, filenames, PyPI package names (i.e., ``distutils`` "distribution" names), and package+version specifiers. In each case, it will attempt to locate the latest available version that meets your criteria. When downloading or processing downloaded files, Easy Install recognizes distutils source distribution files with extensions of .tgz, .tar, .tar.gz, .tar.bz2, or .zip. And of course it handles already-built .egg distributions as well as ``.win32.exe`` installers built using distutils. By default, packages are installed to the running Python installation's ``site-packages`` directory, unless you provide the ``-d`` or ``--install-dir`` option to specify an alternative directory, or specify an alternate location using distutils configuration files. (See `Configuration Files`_, below.) By default, any scripts included with the package are installed to the running Python installation's standard script installation location. However, if you specify an installation directory via the command line or a config file, then the default directory for installing scripts will be the same as the package installation directory, to ensure that the script will have access to the installed package. You can override this using the ``-s`` or ``--script-dir`` option. Installed packages are added to an ``easy-install.pth`` file in the install directory, so that Python will always use the most-recently-installed version of the package. If you would like to be able to select which version to use at runtime, you should use the ``-m`` or ``--multi-version`` option. Upgrading a Package ------------------- You don't need to do anything special to upgrade a package: just install the new version, either by requesting a specific version, e.g.:: easy_install "SomePackage==2.0" a version greater than the one you have now:: easy_install "SomePackage>2.0" using the upgrade flag, to find the latest available version on PyPI:: easy_install --upgrade SomePackage or by using a download page, direct download URL, or package filename:: easy_install -f http://example.com/downloads ExamplePackage easy_install http://example.com/downloads/ExamplePackage-2.0-py2.4.egg easy_install my_downloads/ExamplePackage-2.0.tgz If you're using ``-m`` or ``--multi-version`` , using the ``require()`` function at runtime automatically selects the newest installed version of a package that meets your version criteria. So, installing a newer version is the only step needed to upgrade such packages. If you're installing to a directory on PYTHONPATH, or a configured "site" directory (and not using ``-m``), installing a package automatically replaces any previous version in the ``easy-install.pth`` file, so that Python will import the most-recently installed version by default. So, again, installing the newer version is the only upgrade step needed. If you haven't suppressed script installation (using ``--exclude-scripts`` or ``-x``), then the upgraded version's scripts will be installed, and they will be automatically patched to ``require()`` the corresponding version of the package, so that you can use them even if they are installed in multi-version mode. ``easy_install`` never actually deletes packages (unless you're installing a package with the same name and version number as an existing package), so if you want to get rid of older versions of a package, please see `Uninstalling Packages`_, below. Changing the Active Version --------------------------- If you've upgraded a package, but need to revert to a previously-installed version, you can do so like this:: easy_install PackageName==1.2.3 Where ``1.2.3`` is replaced by the exact version number you wish to switch to. If a package matching the requested name and version is not already installed in a directory on ``sys.path``, it will be located via PyPI and installed. If you'd like to switch to the latest installed version of ``PackageName``, you can do so like this:: easy_install PackageName This will activate the latest installed version. (Note: if you have set any ``find_links`` via distutils configuration files, those download pages will be checked for the latest available version of the package, and it will be downloaded and installed if it is newer than your current version.) Note that changing the active version of a package will install the newly active version's scripts, unless the ``--exclude-scripts`` or ``-x`` option is specified. Uninstalling Packages --------------------- If you have replaced a package with another version, then you can just delete the package(s) you don't need by deleting the PackageName-versioninfo.egg file or directory (found in the installation directory). If you want to delete the currently installed version of a package (or all versions of a package), you should first run:: easy_install -m PackageName This will ensure that Python doesn't continue to search for a package you're planning to remove. After you've done this, you can safely delete the .egg files or directories, along with any scripts you wish to remove. Managing Scripts ---------------- Whenever you install, upgrade, or change versions of a package, EasyInstall automatically installs the scripts for the selected package version, unless you tell it not to with ``-x`` or ``--exclude-scripts``. If any scripts in the script directory have the same name, they are overwritten. Thus, you do not normally need to manually delete scripts for older versions of a package, unless the newer version of the package does not include a script of the same name. However, if you are completely uninstalling a package, you may wish to manually delete its scripts. EasyInstall's default behavior means that you can normally only run scripts from one version of a package at a time. If you want to keep multiple versions of a script available, however, you can simply use the ``--multi-version`` or ``-m`` option, and rename the scripts that EasyInstall creates. This works because EasyInstall installs scripts as short code stubs that ``require()`` the matching version of the package the script came from, so renaming the script has no effect on what it executes. For example, suppose you want to use two versions of the ``rst2html`` tool provided by the `docutils `_ package. You might first install one version:: easy_install -m docutils==0.3.9 then rename the ``rst2html.py`` to ``r2h_039``, and install another version:: easy_install -m docutils==0.3.10 This will create another ``rst2html.py`` script, this one using docutils version 0.3.10 instead of 0.3.9. You now have two scripts, each using a different version of the package. (Notice that we used ``-m`` for both installations, so that Python won't lock us out of using anything but the most recently-installed version of the package.) Executables and Launchers ------------------------- On Unix systems, scripts are installed with as natural files with a "#!" header and no extension and they launch under the Python version indicated in the header. On Windows, there is no mechanism to "execute" files without extensions, so EasyInstall provides two techniques to mirror the Unix behavior. The behavior is indicated by the SETUPTOOLS_LAUNCHER environment variable, which may be "executable" (default) or "natural". Regardless of the technique used, the script(s) will be installed to a Scripts directory (by default in the Python installation directory). It is recommended for EasyInstall that you ensure this directory is in the PATH environment variable. The easiest way to ensure the Scripts directory is in the PATH is to run ``Tools\Scripts\win_add2path.py`` from the Python directory. Note that instead of changing your ``PATH`` to include the Python scripts directory, you can also retarget the installation location for scripts so they go on a directory that's already on the ``PATH``. For more information see `Command-Line Options`_ and `Configuration Files`_. During installation, pass command line options (such as ``--script-dir``) to control where scripts will be installed. Windows Executable Launcher ~~~~~~~~~~~~~~~~~~~~~~~~~~~ If the "executable" launcher is used, EasyInstall will create a '.exe' launcher of the same name beside each installed script (including ``easy_install`` itself). These small .exe files launch the script of the same name using the Python version indicated in the '#!' header. This behavior is currently default. To force the use of executable launchers, set ``SETUPTOOLS_LAUNCHER`` to "executable". Natural Script Launcher ~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall also supports deferring to an external launcher such as `pylauncher `_ for launching scripts. Enable this experimental functionality by setting the ``SETUPTOOLS_LAUNCHER`` environment variable to "natural". EasyInstall will then install scripts as simple scripts with a .pya (or .pyw) extension appended. If these extensions are associated with the pylauncher and listed in the PATHEXT environment variable, these scripts can then be invoked simply and directly just like any other executable. This behavior may become default in a future version. EasyInstall uses the .pya extension instead of simply the typical '.py' extension. This distinct extension is necessary to prevent Python from treating the scripts as importable modules (where name conflicts exist). Current releases of pylauncher do not yet associate with .pya files by default, but future versions should do so. Tips & Techniques ----------------- Multiple Python Versions ~~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall installs itself under two names: ``easy_install`` and ``easy_install-N.N``, where ``N.N`` is the Python version used to install it. Thus, if you install EasyInstall for both Python 3.2 and 2.7, you can use the ``easy_install-3.2`` or ``easy_install-2.7`` scripts to install packages for the respective Python version. Setuptools also supplies easy_install as a runnable module which may be invoked using ``python -m easy_install`` for any Python with Setuptools installed. Restricting Downloads with ``--allow-hosts`` ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can use the ``--allow-hosts`` (``-H``) option to restrict what domains EasyInstall will look for links and downloads on. ``--allow-hosts=None`` prevents downloading altogether. You can also use wildcards, for example to restrict downloading to hosts in your own intranet. See the section below on `Command-Line Options`_ for more details on the ``--allow-hosts`` option. By default, there are no host restrictions in effect, but you can change this default by editing the appropriate `configuration files`_ and adding: .. code-block:: ini [easy_install] allow_hosts = *.myintranet.example.com,*.python.org The above example would then allow downloads only from hosts in the ``python.org`` and ``myintranet.example.com`` domains, unless overridden on the command line. Installing on Un-networked Machines ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Just copy the eggs or source packages you need to a directory on the target machine, then use the ``-f`` or ``--find-links`` option to specify that directory's location. For example:: easy_install -H None -f somedir SomePackage will attempt to install SomePackage using only eggs and source packages found in ``somedir`` and disallowing all remote access. You should of course make sure you have all of SomePackage's dependencies available in somedir. If you have another machine of the same operating system and library versions (or if the packages aren't platform-specific), you can create the directory of eggs using a command like this:: easy_install -zmaxd somedir SomePackage This will tell EasyInstall to put zipped eggs or source packages for SomePackage and all its dependencies into ``somedir``, without creating any scripts or .pth files. You can then copy the contents of ``somedir`` to the target machine. (``-z`` means zipped eggs, ``-m`` means multi-version, which prevents .pth files from being used, ``-a`` means to copy all the eggs needed, even if they're installed elsewhere on the machine, and ``-d`` indicates the directory to place the eggs in.) You can also build the eggs from local development packages that were installed with the ``setup.py develop`` command, by including the ``-l`` option, e.g.:: easy_install -zmaxld somedir SomePackage This will use locally-available source distributions to build the eggs. Packaging Others' Projects As Eggs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Need to distribute a package that isn't published in egg form? You can use EasyInstall to build eggs for a project. You'll want to use the ``--zip-ok``, ``--exclude-scripts``, and possibly ``--no-deps`` options (``-z``, ``-x`` and ``-N``, respectively). Use ``-d`` or ``--install-dir`` to specify the location where you'd like the eggs placed. By placing them in a directory that is published to the web, you can then make the eggs available for download, either in an intranet or to the internet at large. If someone distributes a package in the form of a single ``.py`` file, you can wrap it in an egg by tacking an ``#egg=name-version`` suffix on the file's URL. So, something like this:: easy_install -f "http://some.example.com/downloads/foo.py#egg=foo-1.0" foo will install the package as an egg, and this:: easy_install -zmaxd. \ -f "http://some.example.com/downloads/foo.py#egg=foo-1.0" foo will create a ``.egg`` file in the current directory. Creating your own Package Index ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In addition to local directories and the Python Package Index, EasyInstall can find download links on most any web page whose URL is given to the ``-f`` (``--find-links``) option. In the simplest case, you can simply have a web page with links to eggs or Python source packages, even an automatically generated directory listing (such as the Apache web server provides). If you are setting up an intranet site for package downloads, you may want to configure the target machines to use your download site by default, adding something like this to their `configuration files`_: .. code-block:: ini [easy_install] find_links = http://mypackages.example.com/somedir/ http://turbogears.org/download/ http://peak.telecommunity.com/dist/ As you can see, you can list multiple URLs separated by whitespace, continuing on multiple lines if necessary (as long as the subsequent lines are indented. If you are more ambitious, you can also create an entirely custom package index or PyPI mirror. See the ``--index-url`` option under `Command-Line Options`_, below, and also the section on `Package Index "API"`_. Password-Protected Sites ------------------------ If a site you want to download from is password-protected using HTTP "Basic" authentication, you can specify your credentials in the URL, like so:: http://some_userid:some_password@some.example.com/some_path/ You can do this with both index page URLs and direct download URLs. As long as any HTML pages read by easy_install use *relative* links to point to the downloads, the same user ID and password will be used to do the downloading. Using .pypirc Credentials ------------------------- In additional to supplying credentials in the URL, ``easy_install`` will also honor credentials if present in the .pypirc file. Teams maintaining a private repository of packages may already have defined access credentials for uploading packages according to the distutils documentation. ``easy_install`` will attempt to honor those if present. Refer to the distutils documentation for Python 2.5 or later for details on the syntax. Controlling Build Options ~~~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall respects standard distutils `Configuration Files`_, so you can use them to configure build options for packages that it installs from source. For example, if you are on Windows using the MinGW compiler, you can configure the default compiler by putting something like this: .. code-block:: ini [build] compiler = mingw32 into the appropriate distutils configuration file. In fact, since this is just normal distutils configuration, it will affect any builds using that config file, not just ones done by EasyInstall. For example, if you add those lines to ``distutils.cfg`` in the ``distutils`` package directory, it will be the default compiler for *all* packages you build. See `Configuration Files`_ below for a list of the standard configuration file locations, and links to more documentation on using distutils configuration files. Editing and Viewing Source Packages ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Sometimes a package's source distribution contains additional documentation, examples, configuration files, etc., that are not part of its actual code. If you want to be able to examine these files, you can use the ``--editable`` option to EasyInstall, and EasyInstall will look for a source distribution or Subversion URL for the package, then download and extract it or check it out as a subdirectory of the ``--build-directory`` you specify. If you then wish to install the package after editing or configuring it, you can do so by rerunning EasyInstall with that directory as the target. Note that using ``--editable`` stops EasyInstall from actually building or installing the package; it just finds, obtains, and possibly unpacks it for you. This allows you to make changes to the package if necessary, and to either install it in development mode using ``setup.py develop`` (if the package uses setuptools, that is), or by running ``easy_install projectdir`` (where ``projectdir`` is the subdirectory EasyInstall created for the downloaded package. In order to use ``--editable`` (``-e`` for short), you *must* also supply a ``--build-directory`` (``-b`` for short). The project will be placed in a subdirectory of the build directory. The subdirectory will have the same name as the project itself, but in all-lowercase. If a file or directory of that name already exists, EasyInstall will print an error message and exit. Also, when using ``--editable``, you cannot use URLs or filenames as arguments. You *must* specify project names (and optional version requirements) so that EasyInstall knows what directory name(s) to create. If you need to force EasyInstall to use a particular URL or filename, you should specify it as a ``--find-links`` item (``-f`` for short), and then also specify the project name, e.g.:: easy_install -eb ~/projects \ -fhttp://prdownloads.sourceforge.net/ctypes/ctypes-0.9.6.tar.gz?download \ ctypes==0.9.6 Dealing with Installation Conflicts ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ (NOTE: As of 0.6a11, this section is obsolete; it is retained here only so that people using older versions of EasyInstall can consult it. As of version 0.6a11, installation conflicts are handled automatically without deleting the old or system-installed packages, and without ignoring the issue. Instead, eggs are automatically shifted to the front of ``sys.path`` using special code added to the ``easy-install.pth`` file. So, if you are using version 0.6a11 or better of setuptools, you do not need to worry about conflicts, and the following issues do not apply to you.) EasyInstall installs distributions in a "managed" way, such that each distribution can be independently activated or deactivated on ``sys.path``. However, packages that were not installed by EasyInstall are "unmanaged", in that they usually live all in one directory and cannot be independently activated or deactivated. As a result, if you are using EasyInstall to upgrade an existing package, or to install a package with the same name as an existing package, EasyInstall will warn you of the conflict. (This is an improvement over ``setup.py install``, because the ``distutils`` just install new packages on top of old ones, possibly combining two unrelated packages or leaving behind modules that have been deleted in the newer version of the package.) EasyInstall will stop the installation if it detects a conflict between an existing, "unmanaged" package, and a module or package in any of the distributions you're installing. It will display a list of all of the existing files and directories that would need to be deleted for the new package to be able to function correctly. To proceed, you must manually delete these conflicting files and directories and re-run EasyInstall. Of course, once you've replaced all of your existing "unmanaged" packages with versions managed by EasyInstall, you won't have any more conflicts to worry about! Compressed Installation ~~~~~~~~~~~~~~~~~~~~~~~ EasyInstall tries to install packages in zipped form, if it can. Zipping packages can improve Python's overall import performance if you're not using the ``--multi-version`` option, because Python processes zipfile entries on ``sys.path`` much faster than it does directories. As of version 0.5a9, EasyInstall analyzes packages to determine whether they can be safely installed as a zipfile, and then acts on its analysis. (Previous versions would not install a package as a zipfile unless you used the ``--zip-ok`` option.) The current analysis approach is fairly conservative; it currently looks for: * Any use of the ``__file__`` or ``__path__`` variables (which should be replaced with ``pkg_resources`` API calls) * Possible use of ``inspect`` functions that expect to manipulate source files (e.g. ``inspect.getsource()``) * Top-level modules that might be scripts used with ``python -m`` (Python 2.4) If any of the above are found in the package being installed, EasyInstall will assume that the package cannot be safely run from a zipfile, and unzip it to a directory instead. You can override this analysis with the ``-zip-ok`` flag, which will tell EasyInstall to install the package as a zipfile anyway. Or, you can use the ``--always-unzip`` flag, in which case EasyInstall will always unzip, even if its analysis says the package is safe to run as a zipfile. Normally, however, it is simplest to let EasyInstall handle the determination of whether to zip or unzip, and only specify overrides when needed to work around a problem. If you find you need to override EasyInstall's guesses, you may want to contact the package author and the EasyInstall maintainers, so that they can make appropriate changes in future versions. (Note: If a package uses ``setuptools`` in its setup script, the package author has the option to declare the package safe or unsafe for zipped usage via the ``zip_safe`` argument to ``setup()``. If the package author makes such a declaration, EasyInstall believes the package's author and does not perform its own analysis. However, your command-line option, if any, will still override the package author's choice.) Reference Manual ================ Configuration Files ------------------- (New in 0.4a2) You may specify default options for EasyInstall using the standard distutils configuration files, under the command heading ``easy_install``. EasyInstall will look first for a ``setup.cfg`` file in the current directory, then a ``~/.pydistutils.cfg`` or ``$HOME\\pydistutils.cfg`` (on Unix-like OSes and Windows, respectively), and finally a ``distutils.cfg`` file in the ``distutils`` package directory. Here's a simple example: .. code-block:: ini [easy_install] # set the default location to install packages install_dir = /home/me/lib/python # Notice that indentation can be used to continue an option # value; this is especially useful for the "--find-links" # option, which tells easy_install to use download links on # these pages before consulting PyPI: # find_links = http://sqlobject.org/ http://peak.telecommunity.com/dist/ In addition to accepting configuration for its own options under ``[easy_install]``, EasyInstall also respects defaults specified for other distutils commands. For example, if you don't set an ``install_dir`` for ``[easy_install]``, but *have* set an ``install_lib`` for the ``[install]`` command, this will become EasyInstall's default installation directory. Thus, if you are already using distutils configuration files to set default install locations, build options, etc., EasyInstall will respect your existing settings until and unless you override them explicitly in an ``[easy_install]`` section. For more information, see also the current Python documentation on the `use and location of distutils configuration files `_. Notice that ``easy_install`` will use the ``setup.cfg`` from the current working directory only if it was triggered from ``setup.py`` through the ``install_requires`` option. The standalone command will not use that file. Command-Line Options -------------------- ``--zip-ok, -z`` Install all packages as zip files, even if they are marked as unsafe for running as a zipfile. This can be useful when EasyInstall's analysis of a non-setuptools package is too conservative, but keep in mind that the package may not work correctly. (Changed in 0.5a9; previously this option was required in order for zipped installation to happen at all.) ``--always-unzip, -Z`` Don't install any packages as zip files, even if the packages are marked as safe for running as a zipfile. This can be useful if a package does something unsafe, but not in a way that EasyInstall can easily detect. EasyInstall's default analysis is currently very conservative, however, so you should only use this option if you've had problems with a particular package, and *after* reporting the problem to the package's maintainer and to the EasyInstall maintainers. (Note: the ``-z/-Z`` options only affect the installation of newly-built or downloaded packages that are not already installed in the target directory; if you want to convert an existing installed version from zipped to unzipped or vice versa, you'll need to delete the existing version first, and re-run EasyInstall.) ``--multi-version, -m`` "Multi-version" mode. Specifying this option prevents ``easy_install`` from adding an ``easy-install.pth`` entry for the package being installed, and if an entry for any version the package already exists, it will be removed upon successful installation. In multi-version mode, no specific version of the package is available for importing, unless you use ``pkg_resources.require()`` to put it on ``sys.path``. This can be as simple as:: from pkg_resources import require require("SomePackage", "OtherPackage", "MyPackage") which will put the latest installed version of the specified packages on ``sys.path`` for you. (For more advanced uses, like selecting specific versions and enabling optional dependencies, see the ``pkg_resources`` API doc.) Changed in 0.6a10: this option is no longer silently enabled when installing to a non-PYTHONPATH, non-"site" directory. You must always explicitly use this option if you want it to be active. ``--upgrade, -U`` (New in 0.5a4) By default, EasyInstall only searches online if a project/version requirement can't be met by distributions already installed on sys.path or the installation directory. However, if you supply the ``--upgrade`` or ``-U`` flag, EasyInstall will always check the package index and ``--find-links`` URLs before selecting a version to install. In this way, you can force EasyInstall to use the latest available version of any package it installs (subject to any version requirements that might exclude such later versions). ``--install-dir=DIR, -d DIR`` Set the installation directory. It is up to you to ensure that this directory is on ``sys.path`` at runtime, and to use ``pkg_resources.require()`` to enable the installed package(s) that you need. (New in 0.4a2) If this option is not directly specified on the command line or in a distutils configuration file, the distutils default installation location is used. Normally, this would be the ``site-packages`` directory, but if you are using distutils configuration files, setting things like ``prefix`` or ``install_lib``, then those settings are taken into account when computing the default installation directory, as is the ``--prefix`` option. ``--script-dir=DIR, -s DIR`` Set the script installation directory. If you don't supply this option (via the command line or a configuration file), but you *have* supplied an ``--install-dir`` (via command line or config file), then this option defaults to the same directory, so that the scripts will be able to find their associated package installation. Otherwise, this setting defaults to the location where the distutils would normally install scripts, taking any distutils configuration file settings into account. ``--exclude-scripts, -x`` Don't install scripts. This is useful if you need to install multiple versions of a package, but do not want to reset the version that will be run by scripts that are already installed. ``--user`` (New in 0.6.11) Use the user-site-packages as specified in :pep:`370` instead of the global site-packages. ``--always-copy, -a`` (New in 0.5a4) Copy all needed distributions to the installation directory, even if they are already present in a directory on sys.path. In older versions of EasyInstall, this was the default behavior, but now you must explicitly request it. By default, EasyInstall will no longer copy such distributions from other sys.path directories to the installation directory, unless you explicitly gave the distribution's filename on the command line. Note that as of 0.6a10, using this option excludes "system" and "development" eggs from consideration because they can't be reliably copied. This may cause EasyInstall to choose an older version of a package than what you expected, or it may cause downloading and installation of a fresh copy of something that's already installed. You will see warning messages for any eggs that EasyInstall skips, before it falls back to an older version or attempts to download a fresh copy. ``--find-links=URLS_OR_FILENAMES, -f URLS_OR_FILENAMES`` Scan the specified "download pages" or directories for direct links to eggs or other distributions. Any existing file or directory names or direct download URLs are immediately added to EasyInstall's search cache, and any indirect URLs (ones that don't point to eggs or other recognized archive formats) are added to a list of additional places to search for download links. As soon as EasyInstall has to go online to find a package (either because it doesn't exist locally, or because ``--upgrade`` or ``-U`` was used), the specified URLs will be downloaded and scanned for additional direct links. Eggs and archives found by way of ``--find-links`` are only downloaded if they are needed to meet a requirement specified on the command line; links to unneeded packages are ignored. If all requested packages can be found using links on the specified download pages, the Python Package Index will not be consulted unless you also specified the ``--upgrade`` or ``-U`` option. (Note: if you want to refer to a local HTML file containing links, you must use a ``file:`` URL, as filenames that do not refer to a directory, egg, or archive are ignored.) You may specify multiple URLs or file/directory names with this option, separated by whitespace. Note that on the command line, you will probably have to surround the URL list with quotes, so that it is recognized as a single option value. You can also specify URLs in a configuration file; see `Configuration Files`_, above. Changed in 0.6a10: previously all URLs and directories passed to this option were scanned as early as possible, but from 0.6a10 on, only directories and direct archive links are scanned immediately; URLs are not retrieved unless a package search was already going to go online due to a package not being available locally, or due to the use of the ``--update`` or ``-U`` option. ``--no-find-links`` Blocks the addition of any link. This parameter is useful if you want to avoid adding links defined in a project easy_install is installing (whether it's a requested project or a dependency). When used, ``--find-links`` is ignored. Added in Distribute 0.6.11 and Setuptools 0.7. ``--index-url=URL, -i URL`` (New in 0.4a1; default changed in 0.6c7) Specifies the base URL of the Python Package Index. The default is https://pypi.org/simple/ if not specified. When a package is requested that is not locally available or linked from a ``--find-links`` download page, the package index will be searched for download pages for the needed package, and those download pages will be searched for links to download an egg or source distribution. ``--editable, -e`` (New in 0.6a1) Only find and download source distributions for the specified projects, unpacking them to subdirectories of the specified ``--build-directory``. EasyInstall will not actually build or install the requested projects or their dependencies; it will just find and extract them for you. See `Editing and Viewing Source Packages`_ above for more details. ``--build-directory=DIR, -b DIR`` (UPDATED in 0.6a1) Set the directory used to build source packages. If a package is built from a source distribution or checkout, it will be extracted to a subdirectory of the specified directory. The subdirectory will have the same name as the extracted distribution's project, but in all-lowercase. If a file or directory of that name already exists in the given directory, a warning will be printed to the console, and the build will take place in a temporary directory instead. This option is most useful in combination with the ``--editable`` option, which forces EasyInstall to *only* find and extract (but not build and install) source distributions. See `Editing and Viewing Source Packages`_, above, for more information. ``--verbose, -v, --quiet, -q`` (New in 0.4a4) Control the level of detail of EasyInstall's progress messages. The default detail level is "info", which prints information only about relatively time-consuming operations like running a setup script, unpacking an archive, or retrieving a URL. Using ``-q`` or ``--quiet`` drops the detail level to "warn", which will only display installation reports, warnings, and errors. Using ``-v`` or ``--verbose`` increases the detail level to include individual file-level operations, link analysis messages, and distutils messages from any setup scripts that get run. If you include the ``-v`` option more than once, the second and subsequent uses are passed down to any setup scripts, increasing the verbosity of their reporting as well. ``--dry-run, -n`` (New in 0.4a4) Don't actually install the package or scripts. This option is passed down to any setup scripts run, so packages should not actually build either. This does *not* skip downloading, nor does it skip extracting source distributions to a temporary/build directory. ``--optimize=LEVEL``, ``-O LEVEL`` (New in 0.4a4) If you are installing from a source distribution, and are *not* using the ``--zip-ok`` option, this option controls the optimization level for compiling installed ``.py`` files to ``.pyo`` files. It does not affect the compilation of modules contained in ``.egg`` files, only those in ``.egg`` directories. The optimization level can be set to 0, 1, or 2; the default is 0 (unless it's set under ``install`` or ``install_lib`` in one of your distutils configuration files). ``--record=FILENAME`` (New in 0.5a4) Write a record of all installed files to FILENAME. This is basically the same as the same option for the standard distutils "install" command, and is included for compatibility with tools that expect to pass this option to "setup.py install". ``--site-dirs=DIRLIST, -S DIRLIST`` (New in 0.6a1) Specify one or more custom "site" directories (separated by commas). "Site" directories are directories where ``.pth`` files are processed, such as the main Python ``site-packages`` directory. As of 0.6a10, EasyInstall automatically detects whether a given directory processes ``.pth`` files (or can be made to do so), so you should not normally need to use this option. It is is now only necessary if you want to override EasyInstall's judgment and force an installation directory to be treated as if it supported ``.pth`` files. ``--no-deps, -N`` (New in 0.6a6) Don't install any dependencies. This is intended as a convenience for tools that wrap eggs in a platform-specific packaging system. (We don't recommend that you use it for anything else.) ``--allow-hosts=PATTERNS, -H PATTERNS`` (New in 0.6a6) Restrict downloading and spidering to hosts matching the specified glob patterns. E.g. ``-H *.python.org`` restricts web access so that only packages listed and downloadable from machines in the ``python.org`` domain. The glob patterns must match the *entire* user/host/port section of the target URL(s). For example, ``*.python.org`` will NOT accept a URL like ``http://python.org/foo`` or ``http://www.python.org:8080/``. Multiple patterns can be specified by separating them with commas. The default pattern is ``*``, which matches anything. In general, this option is mainly useful for blocking EasyInstall's web access altogether (e.g. ``-Hlocalhost``), or to restrict it to an intranet or other trusted site. EasyInstall will do the best it can to satisfy dependencies given your host restrictions, but of course can fail if it can't find suitable packages. EasyInstall displays all blocked URLs, so that you can adjust your ``--allow-hosts`` setting if it is more strict than you intended. Some sites may wish to define a restrictive default setting for this option in their `configuration files`_, and then manually override the setting on the command line as needed. ``--prefix=DIR`` (New in 0.6a10) Use the specified directory as a base for computing the default installation and script directories. On Windows, the resulting default directories will be ``prefix\\Lib\\site-packages`` and ``prefix\\Scripts``, while on other platforms the defaults will be ``prefix/lib/python2.X/site-packages`` (with the appropriate version substituted) for libraries and ``prefix/bin`` for scripts. Note that the ``--prefix`` option only sets the *default* installation and script directories, and does not override the ones set on the command line or in a configuration file. ``--local-snapshots-ok, -l`` (New in 0.6c6) Normally, EasyInstall prefers to only install *released* versions of projects, not in-development ones, because such projects may not have a currently-valid version number. So, it usually only installs them when their ``setup.py`` directory is explicitly passed on the command line. However, if this option is used, then any in-development projects that were installed using the ``setup.py develop`` command, will be used to build eggs, effectively upgrading the "in-development" project to a snapshot release. Normally, this option is used only in conjunction with the ``--always-copy`` option to create a distributable snapshot of every egg needed to run an application. Note that if you use this option, you must make sure that there is a valid version number (such as an SVN revision number tag) for any in-development projects that may be used, as otherwise EasyInstall may not be able to tell what version of the project is "newer" when future installations or upgrades are attempted. .. _non-root installation: Custom Installation Locations ----------------------------- By default, EasyInstall installs python packages into Python's main ``site-packages`` directory, and manages them using a custom ``.pth`` file in that same directory. Very often though, a user or developer wants ``easy_install`` to install and manage python packages in an alternative location, usually for one of 3 reasons: 1. They don't have access to write to the main Python site-packages directory. 2. They want a user-specific stash of packages, that is not visible to other users. 3. They want to isolate a set of packages to a specific python application, usually to minimize the possibility of version conflicts. Historically, there have been many approaches to achieve custom installation. The following section lists only the easiest and most relevant approaches [1]_. `Use the "--user" option`_ `Use the "--user" option and customize "PYTHONUSERBASE"`_ `Use "virtualenv"`_ .. [1] There are older ways to achieve custom installation using various ``easy_install`` and ``setup.py install`` options, combined with ``PYTHONPATH`` and/or ``PYTHONUSERBASE`` alterations, but all of these are effectively deprecated by the User scheme brought in by :pep:`370`. Use the "--user" option ~~~~~~~~~~~~~~~~~~~~~~~ Python provides a User scheme for installation, which means that all python distributions support an alternative install location that is specific to a user [3]_. The Default location for each OS is explained in the python documentation for the ``site.USER_BASE`` variable. This mode of installation can be turned on by specifying the ``--user`` option to ``setup.py install`` or ``easy_install``. This approach serves the need to have a user-specific stash of packages. .. [3] Prior to the User scheme, there was the Home scheme, which is still available, but requires more effort than the User scheme to get packages recognized. Use the "--user" option and customize "PYTHONUSERBASE" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The User scheme install location can be customized by setting the ``PYTHONUSERBASE`` environment variable, which updates the value of ``site.USER_BASE``. To isolate packages to a specific application, simply set the OS environment of that application to a specific value of ``PYTHONUSERBASE``, that contains just those packages. Use "virtualenv" ~~~~~~~~~~~~~~~~ "virtualenv" is a 3rd-party python package that effectively "clones" a python installation, thereby creating an isolated location to install packages. The evolution of "virtualenv" started before the existence of the User installation scheme. "virtualenv" provides a version of ``easy_install`` that is scoped to the cloned python install and is used in the normal way. "virtualenv" does offer various features that the User installation scheme alone does not provide, e.g. the ability to hide the main python site-packages. Please refer to the :pypi:`virtualenv` documentation for more details. Package Index "API" ------------------- Custom package indexes (and PyPI) must follow the following rules for EasyInstall to be able to look up and download packages: 1. Except where stated otherwise, "pages" are HTML or XHTML, and "links" refer to ``href`` attributes. 2. Individual project version pages' URLs must be of the form ``base/projectname/version``, where ``base`` is the package index's base URL. 3. Omitting the ``/version`` part of a project page's URL (but keeping the trailing ``/``) should result in a page that is either: a) The single active version of that project, as though the version had been explicitly included, OR b) A page with links to all of the active version pages for that project. 4. Individual project version pages should contain direct links to downloadable distributions where possible. It is explicitly permitted for a project's "long_description" to include URLs, and these should be formatted as HTML links by the package index, as EasyInstall does no special processing to identify what parts of a page are index-specific and which are part of the project's supplied description. 5. Where available, MD5 information should be added to download URLs by appending a fragment identifier of the form ``#md5=...``, where ``...`` is the 32-character hex MD5 digest. EasyInstall will verify that the downloaded file's MD5 digest matches the given value. 6. Individual project version pages should identify any "homepage" or "download" URLs using ``rel="homepage"`` and ``rel="download"`` attributes on the HTML elements linking to those URLs. Use of these attributes will cause EasyInstall to always follow the provided links, unless it can be determined by inspection that they are downloadable distributions. If the links are not to downloadable distributions, they are retrieved, and if they are HTML, they are scanned for download links. They are *not* scanned for additional "homepage" or "download" links, as these are only processed for pages that are part of a package index site. 7. The root URL of the index, if retrieved with a trailing ``/``, must result in a page containing links to *all* projects' active version pages. (Note: This requirement is a workaround for the absence of case-insensitive ``safe_name()`` matching of project names in URL paths. If project names are matched in this fashion (e.g. via the PyPI server, mod_rewrite, or a similar mechanism), then it is not necessary to include this all-packages listing page.) 8. If a package index is accessed via a ``file://`` URL, then EasyInstall will automatically use ``index.html`` files, if present, when trying to read a directory with a trailing ``/`` on the URL. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/functionalities.rst0000644000175100001730000000265314467657412022442 0ustar00runnerdocker"Eggsecutable" Scripts ---------------------- .. deprecated:: 45.3.0 Occasionally, there are situations where it's desirable to make an ``.egg`` file directly executable. You can do this by including an entry point such as the following:: setup( # other arguments here... entry_points={ "setuptools.installation": [ "eggsecutable = my_package.some_module:main_func", ] } ) Any eggs built from the above setup script will include a short executable prelude that imports and calls ``main_func()`` from ``my_package.some_module``. The prelude can be run on Unix-like platforms (including Mac and Linux) by invoking the egg with ``/bin/sh``, or by enabling execute permissions on the ``.egg`` file. For the executable prelude to run, the appropriate version of Python must be available via the ``PATH`` environment variable, under its "long" name. That is, if the egg is built for Python 2.3, there must be a ``python2.3`` executable present in a directory on ``PATH``. IMPORTANT NOTE: Eggs with an "eggsecutable" header cannot be renamed, or invoked via symlinks. They *must* be invoked using their original filename, in order to ensure that, once running, ``pkg_resources`` will know what project and version is in use. The header script will check this and exit with an error if the ``.egg`` file has been renamed or is invoked via a symlink that changes its base name. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/index.rst0000644000175100001730000000153714467657412020351 0ustar00runnerdocker====================================================== Guides on backward compatibility & deprecated practice ====================================================== ``Setuptools`` has undergone tremendous changes since its first debut. As its development continues to roll forward, many of the practice and mechanisms it had established are now considered deprecated. But they still remain relevant as a plethora of libraries continue to depend on them. Many people also find it necessary to equip themselves with the knowledge to better support backward compatibility. This guide aims to provide the essential information for such objectives. .. toctree:: :maxdepth: 1 changed_keywords dependency_links python_eggs easy_install zip_safe resource_extraction distutils/index distutils-legacy functionalities commands ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/python_eggs.rst0000644000175100001730000007433714467657412021600 0ustar00runnerdocker===================================== The Internal Structure of Python Eggs ===================================== STOP! This is not the first document you should read! ---------------------- Eggs and their Formats ---------------------- A "Python egg" is a logical structure embodying the release of a specific version of a Python project, comprising its code, resources, and metadata. There are multiple formats that can be used to physically encode a Python egg, and others can be developed. However, a key principle of Python eggs is that they should be discoverable and importable. That is, it should be possible for a Python application to easily and efficiently find out what eggs are present on a system, and to ensure that the desired eggs' contents are importable. There are two basic formats currently implemented for Python eggs: 1. ``.egg`` format: a directory or zipfile *containing* the project's code and resources, along with an ``EGG-INFO`` subdirectory that contains the project's metadata 2. ``.egg-info`` format: a file or directory placed *adjacent* to the project's code and resources, that directly contains the project's metadata. Both formats can include arbitrary Python code and resources, including static data files, package and non-package directories, Python modules, C extension modules, and so on. But each format is optimized for different purposes. The ``.egg`` format is well-suited to distribution and the easy uninstallation or upgrades of code, since the project is essentially self-contained within a single directory or file, unmingled with any other projects' code or resources. It also makes it possible to have multiple versions of a project simultaneously installed, such that individual programs can select the versions they wish to use. The ``.egg-info`` format, on the other hand, was created to support backward-compatibility, performance, and ease of installation for system packaging tools that expect to install all projects' code and resources to a single directory (e.g. ``site-packages``). Placing the metadata in that same directory simplifies the installation process, since it isn't necessary to create ``.pth`` files or otherwise modify ``sys.path`` to include each installed egg. Its disadvantage, however, is that it provides no support for clean uninstallation or upgrades, and of course only a single version of a project can be installed to a given directory. Thus, support from a package management tool is required. (This is why setuptools' "install" command refers to this type of egg installation as "single-version, externally managed".) Also, they lack sufficient data to allow them to be copied from their installation source. easy_install can "ship" an application by copying ``.egg`` files or directories to a target location, but it cannot do this for ``.egg-info`` installs, because there is no way to tell what code and resources belong to a particular egg -- there may be several eggs "scrambled" together in a single installation location, and the ``.egg-info`` format does not currently include a way to list the files that were installed. (This may change in a future version.) Code and Resources ================== The layout of the code and resources is dictated by Python's normal import layout, relative to the egg's "base location". For the ``.egg`` format, the base location is the ``.egg`` itself. That is, adding the ``.egg`` filename or directory name to ``sys.path`` makes its contents importable. For the ``.egg-info`` format, however, the base location is the directory that *contains* the ``.egg-info``, and thus it is the directory that must be added to ``sys.path`` to make the egg importable. (Note that this means that the "normal" installation of a package to a ``sys.path`` directory is sufficient to make it an "egg" if it has an ``.egg-info`` file or directory installed alongside of it.) Project Metadata ================= If eggs contained only code and resources, there would of course be no difference between them and any other directory or zip file on ``sys.path``. Thus, metadata must also be included, using a metadata file or directory. For the ``.egg`` format, the metadata is placed in an ``EGG-INFO`` subdirectory, directly within the ``.egg`` file or directory. For the ``.egg-info`` format, metadata is stored directly within the ``.egg-info`` directory itself. The minimum project metadata that all eggs must have is a standard Python ``PKG-INFO`` file, named ``PKG-INFO`` and placed within the metadata directory appropriate to the format. Because it's possible for this to be the only metadata file included, ``.egg-info`` format eggs are not required to be a directory; they can just be a ``.egg-info`` file that directly contains the ``PKG-INFO`` metadata. This eliminates the need to create a directory just to store one file. This option is *not* available for ``.egg`` formats, since setuptools always includes other metadata. (In fact, setuptools itself never generates ``.egg-info`` files, either; the support for using files was added so that the requirement could easily be satisfied by other tools, such as distutils). In addition to the ``PKG-INFO`` file, an egg's metadata directory may also include files and directories representing various forms of optional standard metadata (see the section on `Standard Metadata`_, below) or user-defined metadata required by the project. For example, some projects may define a metadata format to describe their application plugins, and metadata in this format would then be included by plugin creators in their projects' metadata directories. Filename-Embedded Metadata ========================== To allow introspection of installed projects and runtime resolution of inter-project dependencies, a certain amount of information is embedded in egg filenames. At a minimum, this includes the project name, and ideally will also include the project version number. Optionally, it can also include the target Python version and required runtime platform if platform-specific C code is included. The syntax of an egg filename is as follows:: name ["-" version ["-py" pyver ["-" required_platform]]] "." ext The "name" and "version" should be escaped using the ``to_filename()`` function provided by ``pkg_resources``, after first processing them with ``safe_name()`` and ``safe_version()`` respectively. These latter two functions can also be used to later "unescape" these parts of the filename. (For a detailed description of these transformations, please see the "Parsing Utilities" section of the ``pkg_resources`` manual.) The "pyver" string is the Python major version, as found in the first 3 characters of ``sys.version``. "required_platform" is essentially a distutils ``get_platform()`` string, but with enhancements to properly distinguish Mac OS versions. (See the ``get_build_platform()`` documentation in the "Platform Utilities" section of the ``pkg_resources`` manual for more details.) Finally, the "ext" is either ``.egg`` or ``.egg-info``, as appropriate for the egg's format. Normally, an egg's filename should include at least the project name and version, as this allows the runtime system to find desired project versions without having to read the egg's PKG-INFO to determine its version number. Setuptools, however, only includes the version number in the filename when an ``.egg`` file is built using the ``bdist_egg`` command, or when an ``.egg-info`` directory is being installed by the ``install_egg_info`` command. When generating metadata for use with the original source tree, it only includes the project name, so that the directory will not have to be renamed each time the project's version changes. This is especially important when version numbers change frequently, and the source metadata directory is kept under version control with the rest of the project. (As would be the case when the project's source includes project-defined metadata that is not generated from by setuptools from data in the setup script.) Egg Links ========= In addition to the ``.egg`` and ``.egg-info`` formats, there is a third egg-related extension that you may encounter on occasion: ``.egg-link`` files. These files are not eggs, strictly speaking. They simply provide a way to reference an egg that is not physically installed in the desired location. They exist primarily as a cross-platform alternative to symbolic links, to support "installing" code that is being developed in a different location than the desired installation location. For example, if a user is developing an application plugin in their home directory, but the plugin needs to be "installed" in an application plugin directory, running "setup.py develop -md /path/to/app/plugins" will install an ``.egg-link`` file in ``/path/to/app/plugins``, that tells the egg runtime system where to find the actual egg (the user's project source directory and its ``.egg-info`` subdirectory). ``.egg-link`` files are named following the format for ``.egg`` and ``.egg-info`` names, but only the project name is included; no version, Python version, or platform information is included. When the runtime searches for available eggs, ``.egg-link`` files are opened and the actual egg file/directory name is read from them. Each ``.egg-link`` file should contain a single file or directory name, with no newlines. This filename should be the base location of one or more eggs. That is, the name must either end in ``.egg``, or else it should be the parent directory of one or more ``.egg-info`` format eggs. As of setuptools 0.6c6, the path may be specified as a platform-independent (i.e. ``/``-separated) relative path from the directory containing the ``.egg-link`` file, and a second line may appear in the file, specifying a platform-independent relative path from the egg's base directory to its setup script directory. This allows installation tools such as EasyInstall to find the project's setup directory and build eggs or perform other setup commands on it. ----------------- Standard Metadata ----------------- In addition to the minimum required ``PKG-INFO`` metadata, projects can include a variety of standard metadata files or directories, as described below. Except as otherwise noted, these files and directories are automatically generated by setuptools, based on information supplied in the setup script or through analysis of the project's code and resources. Most of these files and directories are generated via "egg-info writers" during execution of the setuptools ``egg_info`` command, and are listed in the ``egg_info.writers`` entry point group defined by setuptools' own ``setup.py`` file. Project authors can register their own metadata writers as entry points in this group (as described in the setuptools manual under "Adding new EGG-INFO Files") to cause setuptools to generate project-specific metadata files or directories during execution of the ``egg_info`` command. It is up to project authors to document these new metadata formats, if they create any. ``.txt`` File Formats ===================== Files described in this section that have ``.txt`` extensions have a simple lexical format consisting of a sequence of text lines, each line terminated by a linefeed character (regardless of platform). Leading and trailing whitespace on each line is ignored, as are blank lines and lines whose first nonblank character is a ``#`` (comment symbol). (This is the parsing format defined by the ``yield_lines()`` function of the ``pkg_resources`` module.) All ``.txt`` files defined by this section follow this format, but some are also "sectioned" files, meaning that their contents are divided into sections, using square-bracketed section headers akin to Windows ``.ini`` format. Note that this does *not* imply that the lines within the sections follow an ``.ini`` format, however. Please see an individual metadata file's documentation for a description of what the lines and section names mean in that particular file. Sectioned files can be parsed using the ``split_sections()`` function; see the "Parsing Utilities" section of the ``pkg_resources`` manual for for details. Dependency Metadata =================== ``requires.txt`` ---------------- This is a "sectioned" text file. Each section is a sequence of "requirements", as parsed by the ``parse_requirements()`` function; please see the ``pkg_resources`` manual for the complete requirement parsing syntax. The first, unnamed section (i.e., before the first section header) in this file is the project's core requirements, which must be installed for the project to function. (Specified using the ``install_requires`` keyword to ``setup()``). The remaining (named) sections describe the project's "extra" requirements, as specified using the ``extras_require`` keyword to ``setup()``. The section name is the name of the optional feature, and the section body lists that feature's dependencies. Note that it is not normally necessary to inspect this file directly; ``pkg_resources.Distribution`` objects have a ``requires()`` method that can be used to obtain ``Requirement`` objects describing the project's core and optional dependencies. ``setup_requires.txt`` ---------------------- Much like ``requires.txt`` except represents the requirements specified by the ``setup_requires`` parameter to the Distribution. ``dependency_links.txt`` ------------------------ A list of dependency URLs, one per line, as specified using the ``dependency_links`` keyword to ``setup()``. These may be direct download URLs, or the URLs of web pages containing direct download links. Please see the setuptools manual for more information on specifying this option. ``depends.txt`` -- Obsolete, do not create! ------------------------------------------- This file follows an identical format to ``requires.txt``, but is obsolete and should not be used. The earliest versions of setuptools required users to manually create and maintain this file, so the runtime still supports reading it, if it exists. The new filename was created so that it could be automatically generated from ``setup()`` information without overwriting an existing hand-created ``depends.txt``, if one was already present in the project's source ``.egg-info`` directory. ``namespace_packages.txt`` -- Namespace Package Metadata ======================================================== A list of namespace package names, one per line, as supplied to the ``namespace_packages`` keyword to ``setup()``. Please see the manuals for setuptools and ``pkg_resources`` for more information about namespace packages. ``entry_points.txt`` -- "Entry Point"/Plugin Metadata ===================================================== This is a "sectioned" text file, whose contents encode the ``entry_points`` keyword supplied to ``setup()``. All sections are named, as the section names specify the entry point groups in which the corresponding section's entry points are registered. Each section is a sequence of "entry point" lines, each parseable using the ``EntryPoint.parse`` classmethod; please see the ``pkg_resources`` manual for the complete entry point parsing syntax. Note that it is not necessary to parse this file directly; the ``pkg_resources`` module provides a variety of APIs to locate and load entry points automatically. Please see the setuptools and ``pkg_resources`` manuals for details on the nature and uses of entry points. The ``scripts`` Subdirectory ============================ This directory is currently only created for ``.egg`` files built by the setuptools ``bdist_egg`` command. It will contain copies of all of the project's "traditional" scripts (i.e., those specified using the ``scripts`` keyword to ``setup()``). This is so that they can be reconstituted when an ``.egg`` file is installed. The scripts are placed here using the distutils' standard ``install_scripts`` command, so any ``#!`` lines reflect the Python installation where the egg was built. But instead of copying the scripts to the local script installation directory, EasyInstall writes short wrapper scripts that invoke the original scripts from inside the egg, after ensuring that sys.path includes the egg and any eggs it depends on. For more about `script wrappers`_, see the section below on `Installation and Path Management Issues`_. Zip Support Metadata ==================== ``native_libs.txt`` ------------------- A list of C extensions and other dynamic link libraries contained in the egg, one per line. Paths are ``/``-separated and relative to the egg's base location. This file is generated as part of ``bdist_egg`` processing, and as such only appears in ``.egg`` files (and ``.egg`` directories created by unpacking them). It is used to ensure that all libraries are extracted from a zipped egg at the same time, in case there is any direct linkage between them. Please see the `Zip File Issues`_ section below for more information on library and resource extraction from ``.egg`` files. ``eager_resources.txt`` ----------------------- A list of resource files and/or directories, one per line, as specified via the ``eager_resources`` keyword to ``setup()``. Paths are ``/``-separated and relative to the egg's base location. Resource files or directories listed here will be extracted simultaneously, if any of the named resources are extracted, or if any native libraries listed in ``native_libs.txt`` are extracted. Please see the setuptools manual for details on what this feature is used for and how it works, as well as the `Zip File Issues`_ section below. ``zip-safe`` and ``not-zip-safe`` --------------------------------- These are zero-length files, and either one or the other should exist. If ``zip-safe`` exists, it means that the project will work properly when installed as an ``.egg`` zipfile, and conversely the existence of ``not-zip-safe`` means the project should not be installed as an ``.egg`` file. The ``zip_safe`` option to setuptools' ``setup()`` determines which file will be written. If the option isn't provided, setuptools attempts to make its own assessment of whether the package can work, based on code and content analysis. If neither file is present at installation time, EasyInstall defaults to assuming that the project should be unzipped. (Command-line options to EasyInstall, however, take precedence even over an existing ``zip-safe`` or ``not-zip-safe`` file.) Note that these flag files appear only in ``.egg`` files generated by ``bdist_egg``, and in ``.egg`` directories created by unpacking such an ``.egg`` file. ``top_level.txt`` -- Conflict Management Metadata ================================================= This file is a list of the top-level module or package names provided by the project, one Python identifier per line. Subpackages are not included; a project containing both a ``foo.bar`` and a ``foo.baz`` would include only one line, ``foo``, in its ``top_level.txt``. This data is used by ``pkg_resources`` at runtime to issue a warning if an egg is added to ``sys.path`` when its contained packages may have already been imported. (It was also once used to detect conflicts with non-egg packages at installation time, but in more recent versions, setuptools installs eggs in such a way that they always override non-egg packages, thus preventing a problem from arising.) ``SOURCES.txt`` -- Source Files Manifest ======================================== This file is roughly equivalent to the distutils' ``MANIFEST`` file. The differences are as follows: * The filenames always use ``/`` as a path separator, which must be converted back to a platform-specific path whenever they are read. * The file is automatically generated by setuptools whenever the ``egg_info`` or ``sdist`` commands are run, and it is *not* user-editable. Although this metadata is included with distributed eggs, it is not actually used at runtime for any purpose. Its function is to ensure that setuptools-built *source* distributions can correctly discover what files are part of the project's source, even if the list had been generated using revision control metadata on the original author's system. In other words, ``SOURCES.txt`` has little or no runtime value for being included in distributed eggs, and it is possible that future versions of the ``bdist_egg`` and ``install_egg_info`` commands will strip it before installation or distribution. Therefore, do not rely on its being available outside of an original source directory or source distribution. ------------------------------ Other Technical Considerations ------------------------------ Zip File Issues =============== Although zip files resemble directories, they are not fully substitutable for them. Most platforms do not support loading dynamic link libraries contained in zipfiles, so it is not possible to directly import C extensions from ``.egg`` zipfiles. Similarly, there are many existing libraries -- whether in Python or C -- that require actual operating system filenames, and do not work with arbitrary "file-like" objects or in-memory strings, and thus cannot operate directly on the contents of zip files. To address these issues, the ``pkg_resources`` module provides a "resource API" to support obtaining either the contents of a resource, or a true operating system filename for the resource. If the egg containing the resource is a directory, the resource's real filename is simply returned. However, if the egg is a zipfile, then the resource is first extracted to a cache directory, and the filename within the cache is returned. The cache directory is determined by the ``pkg_resources`` API; please see the ``set_cache_path()`` and ``get_default_cache()`` documentation for details. The Extraction Process ---------------------- Resources are extracted to a cache subdirectory whose name is based on the enclosing ``.egg`` filename and the path to the resource. If there is already a file of the correct name, size, and timestamp, its filename is returned to the requester. Otherwise, the desired file is extracted first to a temporary name generated using ``mkstemp(".$extract",target_dir)``, and then its timestamp is set to match the one in the zip file, before renaming it to its final name. (Some collision detection and resolution code is used to handle the fact that Windows doesn't overwrite files when renaming.) If a resource directory is requested, all of its contents are recursively extracted in this fashion, to ensure that the directory name can be used as if it were valid all along. If the resource requested for extraction is listed in the ``native_libs.txt`` or ``eager_resources.txt`` metadata files, then *all* resources listed in *either* file will be extracted before the requested resource's filename is returned, thus ensuring that all C extensions and data used by them will be simultaneously available. Extension Import Wrappers ------------------------- Since Python's built-in zip import feature does not support loading C extension modules from zipfiles, the setuptools ``bdist_egg`` command generates special import wrappers to make it work. The wrappers are ``.py`` files (along with corresponding ``.pyc`` and/or ``.pyo`` files) that have the same module name as the corresponding C extension. These wrappers are located in the same package directory (or top-level directory) within the zipfile, so that say, ``foomodule.so`` will get a corresponding ``foo.py``, while ``bar/baz.pyd`` will get a corresponding ``bar/baz.py``. These wrapper files contain a short stanza of Python code that asks ``pkg_resources`` for the filename of the corresponding C extension, then reloads the module using the obtained filename. This will cause ``pkg_resources`` to first ensure that all of the egg's C extensions (and any accompanying "eager resources") are extracted to the cache before attempting to link to the C library. Note, by the way, that ``.egg`` directories will also contain these wrapper files. However, Python's default import priority is such that C extensions take precedence over same-named Python modules, so the import wrappers are ignored unless the egg is a zipfile. Installation and Path Management Issues ======================================= Python's initial setup of ``sys.path`` is very dependent on the Python version and installation platform, as well as how Python was started (i.e., script vs. ``-c`` vs. ``-m`` vs. interactive interpreter). In fact, Python also provides only two relatively robust ways to affect ``sys.path`` outside of direct manipulation in code: the ``PYTHONPATH`` environment variable, and ``.pth`` files. However, with no cross-platform way to safely and persistently change environment variables, this leaves ``.pth`` files as EasyInstall's only real option for persistent configuration of ``sys.path``. But ``.pth`` files are rather strictly limited in what they are allowed to do normally. They add directories only to the *end* of ``sys.path``, after any locally-installed ``site-packages`` directory, and they are only processed *in* the ``site-packages`` directory to start with. This is a double whammy for users who lack write access to that directory, because they can't create a ``.pth`` file that Python will read, and even if a sympathetic system administrator adds one for them that calls ``site.addsitedir()`` to allow some other directory to contain ``.pth`` files, they won't be able to install newer versions of anything that's installed in the systemwide ``site-packages``, because their paths will still be added *after* ``site-packages``. So EasyInstall applies two workarounds to solve these problems. The first is that EasyInstall leverages ``.pth`` files' "import" feature to manipulate ``sys.path`` and ensure that anything EasyInstall adds to a ``.pth`` file will always appear before both the standard library and the local ``site-packages`` directories. Thus, it is always possible for a user who can write a Python-read ``.pth`` file to ensure that their packages come first in their own environment. Second, when installing to a ``PYTHONPATH`` directory (as opposed to a "site" directory like ``site-packages``) EasyInstall will also install a special version of the ``site`` module. Because it's in a ``PYTHONPATH`` directory, this module will get control before the standard library version of ``site`` does. It will record the state of ``sys.path`` before invoking the "real" ``site`` module, and then afterwards it processes any ``.pth`` files found in ``PYTHONPATH`` directories, including all the fixups needed to ensure that eggs always appear before the standard library in sys.path, but are in a relative order to one another that is defined by their ``PYTHONPATH`` and ``.pth``-prescribed sequence. The net result of these changes is that ``sys.path`` order will be as follows at runtime: 1. The ``sys.argv[0]`` directory, or an empty string if no script is being executed. 2. All eggs installed by EasyInstall in any ``.pth`` file in each ``PYTHONPATH`` directory, in order first by ``PYTHONPATH`` order, then normal ``.pth`` processing order (which is to say alphabetical by ``.pth`` filename, then by the order of listing within each ``.pth`` file). 3. All eggs installed by EasyInstall in any ``.pth`` file in each "site" directory (such as ``site-packages``), following the same ordering rules as for the ones on ``PYTHONPATH``. 4. The ``PYTHONPATH`` directories themselves, in their original order 5. Any paths from ``.pth`` files found on ``PYTHONPATH`` that were *not* eggs installed by EasyInstall, again following the same relative ordering rules. 6. The standard library and "site" directories, along with the contents of any ``.pth`` files found in the "site" directories. Notice that sections 1, 4, and 6 comprise the "normal" Python setup for ``sys.path``. Sections 2 and 3 are inserted to support eggs, and section 5 emulates what the "normal" semantics of ``.pth`` files on ``PYTHONPATH`` would be if Python natively supported them. For further discussion of the tradeoffs that went into this design, as well as notes on the actual magic inserted into ``.pth`` files to make them do these things, please see also the following messages to the distutils-SIG mailing list: * http://mail.python.org/pipermail/distutils-sig/2006-February/006026.html * http://mail.python.org/pipermail/distutils-sig/2006-March/006123.html Script Wrappers --------------- EasyInstall never directly installs a project's original scripts to a script installation directory. Instead, it writes short wrapper scripts that first ensure that the project's dependencies are active on sys.path, before invoking the original script. These wrappers have a #! line that points to the version of Python that was used to install them, and their second line is always a comment that indicates the type of script wrapper, the project version required for the script to run, and information identifying the script to be invoked. The format of this marker line is:: "# EASY-INSTALL-" script_type ": " tuple_of_strings "\n" The ``script_type`` is one of ``SCRIPT``, ``DEV-SCRIPT``, or ``ENTRY-SCRIPT``. The ``tuple_of_strings`` is a comma-separated sequence of Python string constants. For ``SCRIPT`` and ``DEV-SCRIPT`` wrappers, there are two strings: the project version requirement, and the script name (as a filename within the ``scripts`` metadata directory). For ``ENTRY-SCRIPT`` wrappers, there are three: the project version requirement, the entry point group name, and the entry point name. (See the "Automatic Script Creation" section in the setuptools manual for more information about entry point scripts.) In each case, the project version requirement string will be a string parseable with the ``pkg_resources`` modules' ``Requirement.parse()`` classmethod. The only difference between a ``SCRIPT`` wrapper and a ``DEV-SCRIPT`` is that a ``DEV-SCRIPT`` actually executes the original source script in the project's source tree, and is created when the "setup.py develop" command is run. A ``SCRIPT`` wrapper, on the other hand, uses the "installed" script written to the ``EGG-INFO/scripts`` subdirectory of the corresponding ``.egg`` zipfile or directory. (``.egg-info`` eggs do not have script wrappers associated with them, except in the "setup.py develop" case.) The purpose of including the marker line in generated script wrappers is to facilitate introspection of installed scripts, and their relationship to installed eggs. For example, an uninstallation tool could use this data to identify what scripts can safely be removed, and/or identify what scripts would stop working if a particular egg is uninstalled. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/resource_extraction.rst0000644000175100001730000000574714467657412023340 0ustar00runnerdocker.. _Automatic Resource Extraction: Automatic Resource Extraction ============================= In a modern setup, Python packages are usually installed as directories, and all the files can be found on deterministic locations on the disk. This means that most of the tools expect package resources to be "real" files. There are a few occasions however that packages are loaded in a different way (e.g., from a zip file), which is incompatible with the assumptions mentioned above. Moreover, a package developer may also include non-extension native libraries or other files that C extensions may expect to be able to access. In these scenarios, the use of :mod:`importlib.resources` is recommended. Old implementations (prior to the advent of :mod:`importlib.resources`) and long-living projects, however, may still rely on the library ``pkg_resources`` to access these files. If you have to support such systems, or want to provide backward compatibility for ``pkg_resources``, you may need to add an special configuration to ``setuptools`` when packaging a project. This can be done by listing as ``eager_resources`` (argument to ``setup()`` in ``setup.py`` or field in ``setup.cfg``) all the files that need to be extracted together, whenever a C extension in the project is imported. This is especially important if your project includes shared libraries *other* than ``distutils``/``setuptools``-built C extensions, and those shared libraries use file extensions other than ``.dll``, ``.so``, or ``.dylib``, which are the extensions that setuptools 0.6a8 and higher automatically detects as shared libraries and adds to the ``native_libs.txt`` file for you. Any shared libraries whose names do not end with one of those extensions should be listed as ``eager_resources``, because they need to be present in the filesystem when he C extensions that link to them are used. The ``pkg_resources`` runtime for compressed packages will automatically extract *all* C extensions and ``eager_resources`` at the same time, whenever *any* C extension or eager resource is requested via the ``resource_filename()`` API. (C extensions are imported using ``resource_filename()`` internally.) This ensures that C extensions will see all of the "real" files that they expect to see. Note also that you can list directory resource names in ``eager_resources`` as well, in which case the directory's contents (including subdirectories) will be extracted whenever any C extension or eager resource is requested. Please note that if you're not sure whether you need to use this argument, you don't! It's really intended to support projects with lots of non-Python dependencies and as a last resort for crufty projects that can't otherwise handle being compressed. If your package is pure Python, Python plus data files, or Python plus C, you really don't need this. You've got to be using either C or an external program that needs "real" files in your project before there's any possibility of ``eager_resources`` being relevant to your project. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/deprecated/zip_safe.rst0000644000175100001730000000710114467657412021033 0ustar00runnerdockerUnderstanding the ``zip_safe`` flag =================================== The ``zip_safe`` flag is a ``setuptools`` configuration mainly associated with the ``egg`` distribution format (which got replaced in the ecosystem by the newer ``wheel`` format) and the ``easy_install`` command (deprecated in ``setuptools`` v58.3.0). It is very unlikely that the values of ``zip_safe`` will affect modern deployments that use :pypi:`pip` for installing packages. Moreover, new users of ``setuptools`` should not attempt to create egg files using the deprecated ``build_egg`` command. Therefore, this flag is considered **obsolete**. This document, however, describes what was the historical motivation behind this flag, and how it was used. Historical Motivation --------------------- For some use cases (such as bundling as part of a larger application), Python packages may be run directly from a zip file. Not all packages, however, are capable of running in compressed form, because they may expect to be able to access either source code or data files as normal operating system files. In the past, ``setuptools`` would install a project distributed as a zipfile or a directory (via the ``easy_install`` command or ``python setup.py install``), the default choice being determined by the project's ``zip_safe`` flag. How the ``zip_safe`` flag was used? ----------------------------------- To set this flag, a developer would pass a boolean value for the ``zip_safe`` argument to the ``setup()`` function, or omit it. When omitted, the ``bdist_egg`` command would analyze the project's contents to see if it could detect any conditions preventing the project from working in a zipfile. This was extremely conservative: ``bdist_egg`` would consider the project unsafe if it contained any C extensions or datafiles whatsoever. This does *not* mean that the project couldn't or wouldn't work as a zipfile! It just means that the ``bdist_egg`` authors were not yet comfortable asserting that the project *would* work. If the project did not contain any C or data files, and did not attempt to perform ``__file__`` or ``__path__`` introspection or source code manipulation, then there was an extremely solid chance the project will work when installed as a zipfile. (And if the project used ``pkg_resources`` for all its data file access, then C extensions and other data files shouldn't be a problem at all. See the :ref:`Accessing Data Files at Runtime` section for more information.) The developer could manually set ``zip_safe`` to ``True`` to perform tests, or to override the default behaviour (after checking all the warnings and understanding the implications), this would allow ``setuptools`` to install the project as a zip file. Alternatively, by setting ``zip_safe`` to ``False``, developers could force ``setuptools`` to always install the project as a directory. Modern ways of loading packages from zip files ---------------------------------------------- Currently, popular Python package installers (such as :pypi:`pip`) and package indexes (such as PyPI_) consider that distribution packages are always installed as a directory. It is however still possible to load packages from zip files added to :obj:`sys.path`, thanks to the :mod:`zipimport` module and the :mod:`importlib` machinery provided by Python standard library. When working with modules loaded from a zip file, it is important to keep in mind that values of ``__file__`` and ``__path__`` might not work as expected. Please check the documentation for :mod:`importlib.resources`, if file locations are important for your use case. .. _PyPI: https://pypi.org ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4875476 setuptools-68.1.2/docs/development/0000755000175100001730000000000014467657443016730 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/development/developer-guide.rst0000644000175100001730000001074714467657412022547 0ustar00runnerdocker================================ Developer's Guide for Setuptools ================================ If you want to know more about contributing on Setuptools, this is the place. ------------------- Recommended Reading ------------------- Please read `How to write the perfect pull request `_ for some tips on contributing to open source projects. Although the article is not authoritative, it was authored by the maintainer of Setuptools, so reflects his opinions and will improve the likelihood of acceptance and quality of contribution. ------------------ Project Management ------------------ Setuptools is maintained primarily in GitHub at `this home `_. Setuptools is maintained under the Python Packaging Authority (PyPA) with several core contributors. All bugs for Setuptools are filed and the canonical source is maintained in GitHub. User support and discussions are done through `GitHub Discussions `_, or the issue tracker (for specific issues). Discussions about development happen on GitHub Discussions or the ``setuptools`` channel on `PyPA Discord `_. ----------------- Authoring Tickets ----------------- Before authoring any source code, it's often prudent to file a ticket describing the motivation behind making changes. First search to see if a ticket already exists for your issue. If not, create one. Try to think from the perspective of the reader. Explain what behavior you expected, what you got instead, and what factors might have contributed to the unexpected behavior. In GitHub, surround a block of code or traceback with the triple backtick "\`\`\`" so that it is formatted nicely. Filing a ticket provides a forum for justification, discussion, and clarification. The ticket provides a record of the purpose for the change and any hard decisions that were made. It provides a single place for others to reference when trying to understand why the software operates the way it does or why certain changes were made. Setuptools makes extensive use of hyperlinks to tickets in the changelog so that system integrators and other users can get a quick summary, but then jump to the in-depth discussion about any subject referenced. --------------------- Making a pull request --------------------- When making a pull request, please :ref:`include a short summary of the changes ` and a reference to any issue tickets that the PR is intended to solve. All PRs with code changes should include tests. All changes should include a changelog entry. .. include:: ../../newsfragments/README.rst ------------------- Auto-Merge Requests ------------------- To support running all code through CI, even lightweight contributions, the project employs Mergify to auto-merge pull requests tagged as auto-merge. Use ``hub pull-request -l auto-merge`` to create such a pull request from the command line after pushing a new branch. ------- Testing ------- The primary tests are run using tox. Make sure you have tox installed, and invoke it:: $ tox Under continuous integration, additional tests may be run. See the ``.travis.yml`` file for full details on the tests run under Travis-CI. ------------------- Semantic Versioning ------------------- Setuptools follows ``semver``. .. explain value of reflecting meaning in versions. ---------------------- Building Documentation ---------------------- Setuptools relies on the `Sphinx`_ system for building documentation. The `published documentation`_ is hosted on Read the Docs. To build the docs locally, use tox:: $ tox -e docs .. _Sphinx: http://www.sphinx-doc.org/en/master/ .. _published documentation: https://setuptools.pypa.io/en/latest/ --------------------- Vendored Dependencies --------------------- Setuptools has some dependencies, but due to `bootstrapping issues `_, those dependencies cannot be declared as they won't be resolved soon enough to build setuptools from source. Eventually, this limitation may be lifted as PEP 517/518 reach ubiquitous adoption, but for now, Setuptools cannot declare dependencies other than through ``setuptools/_vendor/vendored.txt`` and ``pkg_resources/_vendor/vendored.txt``. All the dependencies specified in these files are "vendorized" using a simple Python script ``tools/vendor.py``. To refresh the dependencies, run the following command:: $ tox -e vendor ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/development/index.rst0000644000175100001730000000265714467657412020577 0ustar00runnerdocker------------------------- Development on Setuptools ------------------------- Setuptools is maintained by the Python community under the Python Packaging Authority (PyPA) and led by Jason R. Coombs. This document describes the process by which Setuptools is developed. This document assumes the reader has some passing familiarity with *using* setuptools, the ``pkg_resources`` module, and pip. It does not attempt to explain basic concepts like inter-project dependencies, nor does it contain detailed lexical syntax for most file formats. Neither does it explain concepts like "namespace packages" or "resources" in any detail, as all of these subjects are covered at length in the setuptools developer's guide and the ``pkg_resources`` reference manual. Instead, this is **internal** documentation for how those concepts and features are *implemented* in concrete terms. It is intended for people who are working on the setuptools code base, who want to be able to troubleshoot setuptools problems, want to write code that reads the file formats involved, or want to otherwise tinker with setuptools-generated files and directories. Note, however, that these are all internal implementation details and are therefore subject to change; stick to the published API if you don't want to be responsible for keeping your code from breaking when setuptools changes. You have been warned. .. toctree:: :maxdepth: 1 developer-guide releases ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/development/releases.rst0000644000175100001730000000261514467657412021265 0ustar00runnerdocker=============== Release Process =============== In order to allow for rapid, predictable releases, Setuptools uses a mechanical technique for releases, enacted on tagged commits by continuous integration. To finalize a release, run ``tox -e finalize``, review, then push the changes. If tests pass, the release will be uploaded to PyPI. Release Frequency ----------------- Some have asked why Setuptools is released so frequently. Because Setuptools uses a mechanical release process, it's very easy to make releases whenever the code is stable (tests are passing). As a result, the philosophy is to release early and often. While some find the frequent releases somewhat surprising, they only empower the user. Although releases are made frequently, users can choose the frequency at which they use those releases. If instead Setuptools contributions were only released in batches, the user would be constrained to only use Setuptools when those official releases were made. With frequent releases, the user can govern exactly how often he wishes to update. Frequent releases also then obviate the need for dev or beta releases in most cases. Because releases are made early and often, bugs are discovered and corrected quickly, in many cases before other users have yet to encounter them. Release Managers ---------------- Additionally, anyone with push access to the master branch has access to cut releases. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/history.rst0000644000175100001730000000355514467657412016645 0ustar00runnerdocker:tocdepth: 2 .. _changes: History ******* .. towncrier-draft-entries:: DRAFT, unreleased as on |today| .. include:: ../NEWS (links).rst Credits ******* * The original design for the ``.egg`` format and the ``pkg_resources`` API was co-created by Phillip Eby and Bob Ippolito. Bob also implemented the first version of ``pkg_resources``, and supplied the macOS operating system version compatibility algorithm. * Ian Bicking implemented many early "creature comfort" features of easy_install, including support for downloading via Sourceforge and Subversion repositories. Ian's comments on the Web-SIG about WSGI application deployment also inspired the concept of "entry points" in eggs, and he has given talks at PyCon and elsewhere to inform and educate the community about eggs and setuptools. * Jim Fulton contributed time and effort to build automated tests of various aspects of ``easy_install``, and supplied the doctests for the command-line ``.exe`` wrappers on Windows. * Phillip J. Eby is the seminal author of setuptools, and first proposed the idea of an importable binary distribution format for Python application plug-ins. * Significant parts of the implementation of setuptools were funded by the Open Source Applications Foundation, to provide a plug-in infrastructure for the Chandler PIM application. In addition, many OSAF staffers (such as Mike "Code Bear" Taylor) contributed their time and stress as guinea pigs for the use of eggs and setuptools, even before eggs were "cool". (Thanks, guys!) * Tarek Ziadé is the principal author of the Distribute fork, which re-invigorated the community on the project, encouraged renewed innovation, and addressed many defects. * Jason R. Coombs performed the merge with Distribute, maintaining the project for several years in coordination with the Python Packaging Authority (PyPA). ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/index.rst0000644000175100001730000000153014467657412016242 0ustar00runnerdocker.. image:: images/banner-640x320.svg :align: center Documentation ============= Setuptools is a fully-featured, actively-maintained, and stable library designed to facilitate packaging Python projects. It helps developers to easily share reusable code (in the form of a library) and programs (e.g., CLI/GUI tools implemented in Python), that can be installed with :pypi:`pip` and uploaded to `PyPI `_. .. sidebar-links:: :home: :pypi: .. toctree:: :maxdepth: 1 :hidden: User guide build_meta pkg_resources references/keywords setuptools .. toctree:: :caption: Project :maxdepth: 1 :hidden: roadmap Development guide Backward compatibility & deprecated practice Changelog artwork .. tidelift-referral-banner:: ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/pkg_resources.rst0000644000175100001730000027013714467657412020021 0ustar00runnerdocker============================================================= Package Discovery and Resource Access using ``pkg_resources`` ============================================================= The ``pkg_resources`` module distributed with ``setuptools`` provides an API for Python libraries to access their resource files, and for extensible applications and frameworks to automatically discover plugins. It also provides runtime support for using C extensions that are inside zipfile-format eggs, support for merging packages that have separately-distributed modules or subpackages, and APIs for managing Python's current "working set" of active packages. .. attention:: Use of ``pkg_resources`` is deprecated in favor of :mod:`importlib.resources`, :mod:`importlib.metadata` and their backports (:pypi:`importlib_resources`, :pypi:`importlib_metadata`). Some useful APIs are also provided by :pypi:`packaging` (e.g. requirements and version parsing). Users should refrain from new usage of ``pkg_resources`` and should work to port to importlib-based solutions. -------- Overview -------- The ``pkg_resources`` module provides runtime facilities for finding, introspecting, activating and using installed Python distributions. Some of the more advanced features (notably the support for parallel installation of multiple versions) rely specifically on the "egg" format (either as a zip archive or subdirectory), while others (such as plugin discovery) will work correctly so long as "egg-info" metadata directories are available for relevant distributions. Eggs are a distribution format for Python modules, similar in concept to Java's "jars" or Ruby's "gems", or the "wheel" format defined in PEP 427. However, unlike a pure distribution format, eggs can also be installed and added directly to ``sys.path`` as an import location. When installed in this way, eggs are *discoverable*, meaning that they carry metadata that unambiguously identifies their contents and dependencies. This means that an installed egg can be *automatically* found and added to ``sys.path`` in response to simple requests of the form, "get me everything I need to use docutils' PDF support". This feature allows mutually conflicting versions of a distribution to co-exist in the same Python installation, with individual applications activating the desired version at runtime by manipulating the contents of ``sys.path`` (this differs from the virtual environment approach, which involves creating isolated environments for each application). The following terms are needed in order to explain the capabilities offered by this module: project A library, framework, script, plugin, application, or collection of data or other resources, or some combination thereof. Projects are assumed to have "relatively unique" names, e.g. names registered with PyPI. release A snapshot of a project at a particular point in time, denoted by a version identifier. distribution A file or files that represent a particular release. importable distribution A file or directory that, if placed on ``sys.path``, allows Python to import any modules contained within it. pluggable distribution An importable distribution whose filename unambiguously identifies its release (i.e. project and version), and whose contents unambiguously specify what releases of other projects will satisfy its runtime requirements. extra An "extra" is an optional feature of a release, that may impose additional runtime requirements. For example, if docutils PDF support required a PDF support library to be present, docutils could define its PDF support as an "extra", and list what other project releases need to be available in order to provide it. environment A collection of distributions potentially available for importing, but not necessarily active. More than one distribution (i.e. release version) for a given project may be present in an environment. working set A collection of distributions actually available for importing, as on ``sys.path``. At most one distribution (release version) of a given project may be present in a working set, as otherwise there would be ambiguity as to what to import. eggs Eggs are pluggable distributions in one of the three formats currently supported by ``pkg_resources``. There are built eggs, development eggs, and egg links. Built eggs are directories or zipfiles whose name ends with ``.egg`` and follows the egg naming conventions, and contain an ``EGG-INFO`` subdirectory (zipped or otherwise). Development eggs are normal directories of Python code with one or more ``ProjectName.egg-info`` subdirectories. The development egg format is also used to provide a default version of a distribution that is available to software that doesn't use ``pkg_resources`` to request specific versions. Egg links are ``*.egg-link`` files that contain the name of a built or development egg, to support symbolic linking on platforms that do not have native symbolic links (or where the symbolic link support is limited). (For more information about these terms and concepts, see also this `architectural overview`_ of ``pkg_resources`` and Python Eggs in general.) .. _architectural overview: http://mail.python.org/pipermail/distutils-sig/2005-June/004652.html .. ----------------- .. Developer's Guide .. ----------------- .. This section isn't written yet. Currently planned topics include Accessing Resources Finding and Activating Package Distributions get_provider() require() WorkingSet iter_distributions Running Scripts Configuration Namespace Packages Extensible Applications and Frameworks Locating entry points Activation listeners Metadata access Extended Discovery and Installation Supporting Custom PEP 302 Implementations .. For now, please check out the extensive `API Reference`_ below. ------------- API Reference ------------- Namespace Package Support ========================= A namespace package is a package that only contains other packages and modules, with no direct contents of its own. Such packages can be split across multiple, separately-packaged distributions. They are normally used to split up large packages produced by a single organization, such as in the ``zope`` namespace package for Zope Corporation packages, and the ``peak`` namespace package for the Python Enterprise Application Kit. To create a namespace package, you list it in the ``namespace_packages`` argument to ``setup()``, in your project's ``setup.py``. (See the :ref:`setuptools documentation on namespace packages ` for more information on this.) Also, you must add a ``declare_namespace()`` call in the package's ``__init__.py`` file(s): ``declare_namespace(name)`` Declare that the dotted package name ``name`` is a "namespace package" whose contained packages and modules may be spread across multiple distributions. The named package's ``__path__`` will be extended to include the corresponding package in all distributions on ``sys.path`` that contain a package of that name. (More precisely, if an importer's ``find_module(name)`` returns a loader, then it will also be searched for the package's contents.) Whenever a Distribution's ``activate()`` method is invoked, it checks for the presence of namespace packages and updates their ``__path__`` contents accordingly. Applications that manipulate namespace packages or directly alter ``sys.path`` at runtime may also need to use this API function: ``fixup_namespace_packages(path_item)`` Declare that ``path_item`` is a newly added item on ``sys.path`` that may need to be used to update existing namespace packages. Ordinarily, this is called for you when an egg is automatically added to ``sys.path``, but if your application modifies ``sys.path`` to include locations that may contain portions of a namespace package, you will need to call this function to ensure they are added to the existing namespace packages. Although by default ``pkg_resources`` only supports namespace packages for filesystem and zip importers, you can extend its support to other "importers" compatible with PEP 302 using the ``register_namespace_handler()`` function. See the section below on `Supporting Custom Importers`_ for details. ``WorkingSet`` Objects ====================== The ``WorkingSet`` class provides access to a collection of "active" distributions. In general, there is only one meaningful ``WorkingSet`` instance: the one that represents the distributions that are currently active on ``sys.path``. This global instance is available under the name ``working_set`` in the ``pkg_resources`` module. However, specialized tools may wish to manipulate working sets that don't correspond to ``sys.path``, and therefore may wish to create other ``WorkingSet`` instances. It's important to note that the global ``working_set`` object is initialized from ``sys.path`` when ``pkg_resources`` is first imported, but is only updated if you do all future ``sys.path`` manipulation via ``pkg_resources`` APIs. If you manually modify ``sys.path``, you must invoke the appropriate methods on the ``working_set`` instance to keep it in sync. Unfortunately, Python does not provide any way to detect arbitrary changes to a list object like ``sys.path``, so ``pkg_resources`` cannot automatically update the ``working_set`` based on changes to ``sys.path``. ``WorkingSet(entries=None)`` Create a ``WorkingSet`` from an iterable of path entries. If ``entries`` is not supplied, it defaults to the value of ``sys.path`` at the time the constructor is called. Note that you will not normally construct ``WorkingSet`` instances yourself, but instead you will implicitly or explicitly use the global ``working_set`` instance. For the most part, the ``pkg_resources`` API is designed so that the ``working_set`` is used by default, such that you don't have to explicitly refer to it most of the time. All distributions available directly on ``sys.path`` will be activated automatically when ``pkg_resources`` is imported. This behaviour can cause version conflicts for applications which require non-default versions of those distributions. To handle this situation, ``pkg_resources`` checks for a ``__requires__`` attribute in the ``__main__`` module when initializing the default working set, and uses this to ensure a suitable version of each affected distribution is activated. For example:: __requires__ = ["CherryPy < 3"] # Must be set before pkg_resources import import pkg_resources Basic ``WorkingSet`` Methods ---------------------------- The following methods of ``WorkingSet`` objects are also available as module-level functions in ``pkg_resources`` that apply to the default ``working_set`` instance. Thus, you can use e.g. ``pkg_resources.require()`` as an abbreviation for ``pkg_resources.working_set.require()``: ``require(*requirements)`` Ensure that distributions matching ``requirements`` are activated ``requirements`` must be a string or a (possibly-nested) sequence thereof, specifying the distributions and versions required. The return value is a sequence of the distributions that needed to be activated to fulfill the requirements; all relevant distributions are included, even if they were already activated in this working set. For the syntax of requirement specifiers, see the section below on `Requirements Parsing`_. In general, it should not be necessary for you to call this method directly. It's intended more for use in quick-and-dirty scripting and interactive interpreter hacking than for production use. If you're creating an actual library or application, it's strongly recommended that you create a "setup.py" script using ``setuptools``, and declare all your requirements there. That way, tools like pip can automatically detect what requirements your package has, and deal with them accordingly. Note that calling ``require('SomePackage')`` will not install ``SomePackage`` if it isn't already present. If you need to do this, you should use the ``resolve()`` method instead, which allows you to pass an ``installer`` callback that will be invoked when a needed distribution can't be found on the local machine. You can then have this callback display a dialog, automatically download the needed distribution, or whatever else is appropriate for your application. See the documentation below on the ``resolve()`` method for more information, and also on the ``obtain()`` method of ``Environment`` objects. ``run_script(requires, script_name)`` Locate distribution specified by ``requires`` and run its ``script_name`` script. ``requires`` must be a string containing a requirement specifier. (See `Requirements Parsing`_ below for the syntax.) The script, if found, will be executed in *the caller's globals*. That's because this method is intended to be called from wrapper scripts that act as a proxy for the "real" scripts in a distribution. A wrapper script usually doesn't need to do anything but invoke this function with the correct arguments. If you need more control over the script execution environment, you probably want to use the ``run_script()`` method of a ``Distribution`` object's `Metadata API`_ instead. ``iter_entry_points(group, name=None)`` Yield entry point objects from ``group`` matching ``name`` If ``name`` is None, yields all entry points in ``group`` from all distributions in the working set, otherwise only ones matching both ``group`` and ``name`` are yielded. Entry points are yielded from the active distributions in the order that the distributions appear in the working set. (For the global ``working_set``, this should be the same as the order that they are listed in ``sys.path``.) Note that within the entry points advertised by an individual distribution, there is no particular ordering. Please see the section below on `Entry Points`_ for more information. ``WorkingSet`` Methods and Attributes ------------------------------------- These methods are used to query or manipulate the contents of a specific working set, so they must be explicitly invoked on a particular ``WorkingSet`` instance: ``add_entry(entry)`` Add a path item to the ``entries``, finding any distributions on it. You should use this when you add additional items to ``sys.path`` and you want the global ``working_set`` to reflect the change. This method is also called by the ``WorkingSet()`` constructor during initialization. This method uses ``find_distributions(entry,True)`` to find distributions corresponding to the path entry, and then ``add()`` them. ``entry`` is always appended to the ``entries`` attribute, even if it is already present, however. (This is because ``sys.path`` can contain the same value more than once, and the ``entries`` attribute should be able to reflect this.) ``__contains__(dist)`` True if ``dist`` is active in this ``WorkingSet``. Note that only one distribution for a given project can be active in a given ``WorkingSet``. ``__iter__()`` Yield distributions for non-duplicate projects in the working set. The yield order is the order in which the items' path entries were added to the working set. ``find(req)`` Find a distribution matching ``req`` (a ``Requirement`` instance). If there is an active distribution for the requested project, this returns it, as long as it meets the version requirement specified by ``req``. But, if there is an active distribution for the project and it does *not* meet the ``req`` requirement, ``VersionConflict`` is raised. If there is no active distribution for the requested project, ``None`` is returned. ``resolve(requirements, env=None, installer=None)`` List all distributions needed to (recursively) meet ``requirements`` ``requirements`` must be a sequence of ``Requirement`` objects. ``env``, if supplied, should be an ``Environment`` instance. If not supplied, an ``Environment`` is created from the working set's ``entries``. ``installer``, if supplied, will be invoked with each requirement that cannot be met by an already-installed distribution; it should return a ``Distribution`` or ``None``. (See the ``obtain()`` method of `Environment Objects`_, below, for more information on the ``installer`` argument.) ``add(dist, entry=None)`` Add ``dist`` to working set, associated with ``entry`` If ``entry`` is unspecified, it defaults to ``dist.location``. On exit from this routine, ``entry`` is added to the end of the working set's ``.entries`` (if it wasn't already present). ``dist`` is only added to the working set if it's for a project that doesn't already have a distribution active in the set. If it's successfully added, any callbacks registered with the ``subscribe()`` method will be called. (See `Receiving Change Notifications`_, below.) Note: ``add()`` is automatically called for you by the ``require()`` method, so you don't normally need to use this method directly. ``entries`` This attribute represents a "shadow" ``sys.path``, primarily useful for debugging. If you are experiencing import problems, you should check the global ``working_set`` object's ``entries`` against ``sys.path``, to ensure that they match. If they do not, then some part of your program is manipulating ``sys.path`` without updating the ``working_set`` accordingly. IMPORTANT NOTE: do not directly manipulate this attribute! Setting it equal to ``sys.path`` will not fix your problem, any more than putting black tape over an "engine warning" light will fix your car! If this attribute is out of sync with ``sys.path``, it's merely an *indicator* of the problem, not the cause of it. Receiving Change Notifications ------------------------------ Extensible applications and frameworks may need to receive notification when a new distribution (such as a plug-in component) has been added to a working set. This is what the ``subscribe()`` method and ``add_activation_listener()`` function are for. ``subscribe(callback)`` Invoke ``callback(distribution)`` once for each active distribution that is in the set now, or gets added later. Because the callback is invoked for already-active distributions, you do not need to loop over the working set yourself to deal with the existing items; just register the callback and be prepared for the fact that it will be called immediately by this method. Note that callbacks *must not* allow exceptions to propagate, or they will interfere with the operation of other callbacks and possibly result in an inconsistent working set state. Callbacks should use a try/except block to ignore, log, or otherwise process any errors, especially since the code that caused the callback to be invoked is unlikely to be able to handle the errors any better than the callback itself. ``pkg_resources.add_activation_listener()`` is an alternate spelling of ``pkg_resources.working_set.subscribe()``. Locating Plugins ---------------- Extensible applications will sometimes have a "plugin directory" or a set of plugin directories, from which they want to load entry points or other metadata. The ``find_plugins()`` method allows you to do this, by scanning an environment for the newest version of each project that can be safely loaded without conflicts or missing requirements. ``find_plugins(plugin_env, full_env=None, fallback=True)`` Scan ``plugin_env`` and identify which distributions could be added to this working set without version conflicts or missing requirements. Example usage:: distributions, errors = working_set.find_plugins( Environment(plugin_dirlist) ) map(working_set.add, distributions) # add plugins+libs to sys.path print "Couldn't load", errors # display errors The ``plugin_env`` should be an ``Environment`` instance that contains only distributions that are in the project's "plugin directory" or directories. The ``full_env``, if supplied, should be an ``Environment`` instance that contains all currently-available distributions. If ``full_env`` is not supplied, one is created automatically from the ``WorkingSet`` this method is called on, which will typically mean that every directory on ``sys.path`` will be scanned for distributions. This method returns a 2-tuple: (``distributions``, ``error_info``), where ``distributions`` is a list of the distributions found in ``plugin_env`` that were loadable, along with any other distributions that are needed to resolve their dependencies. ``error_info`` is a dictionary mapping unloadable plugin distributions to an exception instance describing the error that occurred. Usually this will be a ``DistributionNotFound`` or ``VersionConflict`` instance. Most applications will use this method mainly on the master ``working_set`` instance in ``pkg_resources``, and then immediately add the returned distributions to the working set so that they are available on sys.path. This will make it possible to find any entry points, and allow any other metadata tracking and hooks to be activated. The resolution algorithm used by ``find_plugins()`` is as follows. First, the project names of the distributions present in ``plugin_env`` are sorted. Then, each project's eggs are tried in descending version order (i.e., newest version first). An attempt is made to resolve each egg's dependencies. If the attempt is successful, the egg and its dependencies are added to the output list and to a temporary copy of the working set. The resolution process continues with the next project name, and no older eggs for that project are tried. If the resolution attempt fails, however, the error is added to the error dictionary. If the ``fallback`` flag is true, the next older version of the plugin is tried, until a working version is found. If false, the resolution process continues with the next plugin project name. Some applications may have stricter fallback requirements than others. For example, an application that has a database schema or persistent objects may not be able to safely downgrade a version of a package. Others may want to ensure that a new plugin configuration is either 100% good or else revert to a known-good configuration. (That is, they may wish to revert to a known configuration if the ``error_info`` return value is non-empty.) Note that this algorithm gives precedence to satisfying the dependencies of alphabetically prior project names in case of version conflicts. If two projects named "AaronsPlugin" and "ZekesPlugin" both need different versions of "TomsLibrary", then "AaronsPlugin" will win and "ZekesPlugin" will be disabled due to version conflict. ``Environment`` Objects ======================= An "environment" is a collection of ``Distribution`` objects, usually ones that are present and potentially importable on the current platform. ``Environment`` objects are used by ``pkg_resources`` to index available distributions during dependency resolution. ``Environment(search_path=None, platform=get_supported_platform(), python=PY_MAJOR)`` Create an environment snapshot by scanning ``search_path`` for distributions compatible with ``platform`` and ``python``. ``search_path`` should be a sequence of strings such as might be used on ``sys.path``. If a ``search_path`` isn't supplied, ``sys.path`` is used. ``platform`` is an optional string specifying the name of the platform that platform-specific distributions must be compatible with. If unspecified, it defaults to the current platform. ``python`` is an optional string naming the desired version of Python (e.g. ``'2.4'``); it defaults to the currently-running version. You may explicitly set ``platform`` (and/or ``python``) to ``None`` if you wish to include *all* distributions, not just those compatible with the running platform or Python version. Note that ``search_path`` is scanned immediately for distributions, and the resulting ``Environment`` is a snapshot of the found distributions. It is not automatically updated if the system's state changes due to e.g. installation or removal of distributions. ``__getitem__(project_name)`` Returns a list of distributions for the given project name, ordered from newest to oldest version. (And highest to lowest format precedence for distributions that contain the same version of the project.) If there are no distributions for the project, returns an empty list. ``__iter__()`` Yield the unique project names of the distributions in this environment. The yielded names are always in lower case. ``add(dist)`` Add ``dist`` to the environment if it matches the platform and python version specified at creation time, and only if the distribution hasn't already been added. (i.e., adding the same distribution more than once is a no-op.) ``remove(dist)`` Remove ``dist`` from the environment. ``can_add(dist)`` Is distribution ``dist`` acceptable for this environment? If it's not compatible with the ``platform`` and ``python`` version values specified when the environment was created, a false value is returned. ``__add__(dist_or_env)`` (``+`` operator) Add a distribution or environment to an ``Environment`` instance, returning a *new* environment object that contains all the distributions previously contained by both. The new environment will have a ``platform`` and ``python`` of ``None``, meaning that it will not reject any distributions from being added to it; it will simply accept whatever is added. If you want the added items to be filtered for platform and Python version, or you want to add them to the *same* environment instance, you should use in-place addition (``+=``) instead. ``__iadd__(dist_or_env)`` (``+=`` operator) Add a distribution or environment to an ``Environment`` instance *in-place*, updating the existing instance and returning it. The ``platform`` and ``python`` filter attributes take effect, so distributions in the source that do not have a suitable platform string or Python version are silently ignored. ``best_match(req, working_set, installer=None)`` Find distribution best matching ``req`` and usable on ``working_set`` This calls the ``find(req)`` method of the ``working_set`` to see if a suitable distribution is already active. (This may raise ``VersionConflict`` if an unsuitable version of the project is already active in the specified ``working_set``.) If a suitable distribution isn't active, this method returns the newest distribution in the environment that meets the ``Requirement`` in ``req``. If no suitable distribution is found, and ``installer`` is supplied, then the result of calling the environment's ``obtain(req, installer)`` method will be returned. ``obtain(requirement, installer=None)`` Obtain a distro that matches requirement (e.g. via download). In the base ``Environment`` class, this routine just returns ``installer(requirement)``, unless ``installer`` is None, in which case None is returned instead. This method is a hook that allows subclasses to attempt other ways of obtaining a distribution before falling back to the ``installer`` argument. ``scan(search_path=None)`` Scan ``search_path`` for distributions usable on ``platform`` Any distributions found are added to the environment. ``search_path`` should be a sequence of strings such as might be used on ``sys.path``. If not supplied, ``sys.path`` is used. Only distributions conforming to the platform/python version defined at initialization are added. This method is a shortcut for using the ``find_distributions()`` function to find the distributions from each item in ``search_path``, and then calling ``add()`` to add each one to the environment. ``Requirement`` Objects ======================= ``Requirement`` objects express what versions of a project are suitable for some purpose. These objects (or their string form) are used by various ``pkg_resources`` APIs in order to find distributions that a script or distribution needs. Requirements Parsing -------------------- ``parse_requirements(s)`` Yield ``Requirement`` objects for a string or iterable of lines. Each requirement must start on a new line. See below for syntax. ``Requirement.parse(s)`` Create a ``Requirement`` object from a string or iterable of lines. A ``ValueError`` is raised if the string or lines do not contain a valid requirement specifier, or if they contain more than one specifier. (To parse multiple specifiers from a string or iterable of strings, use ``parse_requirements()`` instead.) The syntax of a requirement specifier is defined in full in PEP 508. Some examples of valid requirement specifiers:: FooProject >= 1.2 Fizzy [foo, bar] PickyThing>1.6,<=1.9,!=1.8.6 SomethingWhoseVersionIDontCareAbout SomethingWithMarker[foo]>1.0;python_version<"2.7" The project name is the only required portion of a requirement string, and if it's the only thing supplied, the requirement will accept any version of that project. The "extras" in a requirement are used to request optional features of a project, that may require additional project distributions in order to function. For example, if the hypothetical "Report-O-Rama" project offered optional PDF support, it might require an additional library in order to provide that support. Thus, a project needing Report-O-Rama's PDF features could use a requirement of ``Report-O-Rama[PDF]`` to request installation or activation of both Report-O-Rama and any libraries it needs in order to provide PDF support. For example, you could use:: pip install Report-O-Rama[PDF] To install the necessary packages using pip, or call ``pkg_resources.require('Report-O-Rama[PDF]')`` to add the necessary distributions to sys.path at runtime. The "markers" in a requirement are used to specify when a requirement should be installed -- the requirement will be installed if the marker evaluates as true in the current environment. For example, specifying ``argparse;python_version<"3.0"`` will not install in an Python 3 environment, but will in a Python 2 environment. ``Requirement`` Methods and Attributes -------------------------------------- ``__contains__(dist_or_version)`` Return true if ``dist_or_version`` fits the criteria for this requirement. If ``dist_or_version`` is a ``Distribution`` object, its project name must match the requirement's project name, and its version must meet the requirement's version criteria. If ``dist_or_version`` is a string, it is parsed using the ``parse_version()`` utility function. Otherwise, it is assumed to be an already-parsed version. The ``Requirement`` object's version specifiers (``.specs``) are internally sorted into ascending version order, and used to establish what ranges of versions are acceptable. Adjacent redundant conditions are effectively consolidated (e.g. ``">1, >2"`` produces the same results as ``">2"``, and ``"<2,<3"`` produces the same results as ``"<2"``). ``"!="`` versions are excised from the ranges they fall within. The version being tested for acceptability is then checked for membership in the resulting ranges. ``__eq__(other_requirement)`` A requirement compares equal to another requirement if they have case-insensitively equal project names, version specifiers, and "extras". (The order that extras and version specifiers are in is also ignored.) Equal requirements also have equal hashes, so that requirements can be used in sets or as dictionary keys. ``__str__()`` The string form of a ``Requirement`` is a string that, if passed to ``Requirement.parse()``, would return an equal ``Requirement`` object. ``project_name`` The name of the required project ``key`` An all-lowercase version of the ``project_name``, useful for comparison or indexing. ``extras`` A tuple of names of "extras" that this requirement calls for. (These will be all-lowercase and normalized using the ``safe_extra()`` parsing utility function, so they may not exactly equal the extras the requirement was created with.) ``specs`` A list of ``(op,version)`` tuples, sorted in ascending parsed-version order. The ``op`` in each tuple is a comparison operator, represented as a string. The ``version`` is the (unparsed) version number. ``marker`` An instance of ``packaging.markers.Marker`` that allows evaluation against the current environment. May be None if no marker specified. ``url`` The location to download the requirement from if specified. Entry Points ============ Entry points are a simple way for distributions to "advertise" Python objects (such as functions or classes) for use by other distributions. Extensible applications and frameworks can search for entry points with a particular name or group, either from a specific distribution or from all active distributions on sys.path, and then inspect or load the advertised objects at will. Entry points belong to "groups" which are named with a dotted name similar to a Python package or module name. For example, the ``setuptools`` package uses an entry point named ``distutils.commands`` in order to find commands defined by distutils extensions. ``setuptools`` treats the names of entry points defined in that group as the acceptable commands for a setup script. In a similar way, other packages can define their own entry point groups, either using dynamic names within the group (like ``distutils.commands``), or possibly using predefined names within the group. For example, a blogging framework that offers various pre- or post-publishing hooks might define an entry point group and look for entry points named "pre_process" and "post_process" within that group. To advertise an entry point, a project needs to use ``setuptools`` and provide an ``entry_points`` argument to ``setup()`` in its setup script, so that the entry points will be included in the distribution's metadata. For more details, see :ref:`Advertising Behavior`. Each project distribution can advertise at most one entry point of a given name within the same entry point group. For example, a distutils extension could advertise two different ``distutils.commands`` entry points, as long as they had different names. However, there is nothing that prevents *different* projects from advertising entry points of the same name in the same group. In some cases, this is a desirable thing, since the application or framework that uses the entry points may be calling them as hooks, or in some other way combining them. It is up to the application or framework to decide what to do if multiple distributions advertise an entry point; some possibilities include using both entry points, displaying an error message, using the first one found in sys.path order, etc. Convenience API --------------- In the following functions, the ``dist`` argument can be a ``Distribution`` instance, a ``Requirement`` instance, or a string specifying a requirement (i.e. project name, version, etc.). If the argument is a string or ``Requirement``, the specified distribution is located (and added to sys.path if not already present). An error will be raised if a matching distribution is not available. The ``group`` argument should be a string containing a dotted identifier, identifying an entry point group. If you are defining an entry point group, you should include some portion of your package's name in the group name so as to avoid collision with other packages' entry point groups. ``load_entry_point(dist, group, name)`` Load the named entry point from the specified distribution, or raise ``ImportError``. ``get_entry_info(dist, group, name)`` Return an ``EntryPoint`` object for the given ``group`` and ``name`` from the specified distribution. Returns ``None`` if the distribution has not advertised a matching entry point. ``get_entry_map(dist, group=None)`` Return the distribution's entry point map for ``group``, or the full entry map for the distribution. This function always returns a dictionary, even if the distribution advertises no entry points. If ``group`` is given, the dictionary maps entry point names to the corresponding ``EntryPoint`` object. If ``group`` is None, the dictionary maps group names to dictionaries that then map entry point names to the corresponding ``EntryPoint`` instance in that group. ``iter_entry_points(group, name=None)`` Yield entry point objects from ``group`` matching ``name``. If ``name`` is None, yields all entry points in ``group`` from all distributions in the working set on sys.path, otherwise only ones matching both ``group`` and ``name`` are yielded. Entry points are yielded from the active distributions in the order that the distributions appear on sys.path. (Within entry points for a particular distribution, however, there is no particular ordering.) (This API is actually a method of the global ``working_set`` object; see the section above on `Basic WorkingSet Methods`_ for more information.) Creating and Parsing -------------------- ``EntryPoint(name, module_name, attrs=(), extras=(), dist=None)`` Create an ``EntryPoint`` instance. ``name`` is the entry point name. The ``module_name`` is the (dotted) name of the module containing the advertised object. ``attrs`` is an optional tuple of names to look up from the module to obtain the advertised object. For example, an ``attrs`` of ``("foo","bar")`` and a ``module_name`` of ``"baz"`` would mean that the advertised object could be obtained by the following code:: import baz advertised_object = baz.foo.bar The ``extras`` are an optional tuple of "extra feature" names that the distribution needs in order to provide this entry point. When the entry point is loaded, these extra features are looked up in the ``dist`` argument to find out what other distributions may need to be activated on sys.path; see the ``load()`` method for more details. The ``extras`` argument is only meaningful if ``dist`` is specified. ``dist`` must be a ``Distribution`` instance. ``EntryPoint.parse(src, dist=None)`` (classmethod) Parse a single entry point from string ``src`` Entry point syntax follows the form:: name = some.module:some.attr [extra1,extra2] The entry name and module name are required, but the ``:attrs`` and ``[extras]`` parts are optional, as is the whitespace shown between some of the items. The ``dist`` argument is passed through to the ``EntryPoint()`` constructor, along with the other values parsed from ``src``. ``EntryPoint.parse_group(group, lines, dist=None)`` (classmethod) Parse ``lines`` (a string or sequence of lines) to create a dictionary mapping entry point names to ``EntryPoint`` objects. ``ValueError`` is raised if entry point names are duplicated, if ``group`` is not a valid entry point group name, or if there are any syntax errors. (Note: the ``group`` parameter is used only for validation and to create more informative error messages.) If ``dist`` is provided, it will be used to set the ``dist`` attribute of the created ``EntryPoint`` objects. ``EntryPoint.parse_map(data, dist=None)`` (classmethod) Parse ``data`` into a dictionary mapping group names to dictionaries mapping entry point names to ``EntryPoint`` objects. If ``data`` is a dictionary, then the keys are used as group names and the values are passed to ``parse_group()`` as the ``lines`` argument. If ``data`` is a string or sequence of lines, it is first split into .ini-style sections (using the ``split_sections()`` utility function) and the section names are used as group names. In either case, the ``dist`` argument is passed through to ``parse_group()`` so that the entry points will be linked to the specified distribution. ``EntryPoint`` Objects ---------------------- For simple introspection, ``EntryPoint`` objects have attributes that correspond exactly to the constructor argument names: ``name``, ``module_name``, ``attrs``, ``extras``, and ``dist`` are all available. In addition, the following methods are provided: ``load()`` Load the entry point, returning the advertised Python object. Effectively calls ``self.require()`` then returns ``self.resolve()``. ``require(env=None, installer=None)`` Ensure that any "extras" needed by the entry point are available on sys.path. ``UnknownExtra`` is raised if the ``EntryPoint`` has ``extras``, but no ``dist``, or if the named extras are not defined by the distribution. If ``env`` is supplied, it must be an ``Environment``, and it will be used to search for needed distributions if they are not already present on sys.path. If ``installer`` is supplied, it must be a callable taking a ``Requirement`` instance and returning a matching importable ``Distribution`` instance or None. ``resolve()`` Resolve the entry point from its module and attrs, returning the advertised Python object. Raises ``ImportError`` if it cannot be obtained. ``__str__()`` The string form of an ``EntryPoint`` is a string that could be passed to ``EntryPoint.parse()`` to produce an equivalent ``EntryPoint``. ``Distribution`` Objects ======================== ``Distribution`` objects represent collections of Python code that may or may not be importable, and may or may not have metadata and resources associated with them. Their metadata may include information such as what other projects the distribution depends on, what entry points the distribution advertises, and so on. Getting or Creating Distributions --------------------------------- Most commonly, you'll obtain ``Distribution`` objects from a ``WorkingSet`` or an ``Environment``. (See the sections above on `WorkingSet Objects`_ and `Environment Objects`_, which are containers for active distributions and available distributions, respectively.) You can also obtain ``Distribution`` objects from one of these high-level APIs: ``find_distributions(path_item, only=False)`` Yield distributions accessible via ``path_item``. If ``only`` is true, yield only distributions whose ``location`` is equal to ``path_item``. In other words, if ``only`` is true, this yields any distributions that would be importable if ``path_item`` were on ``sys.path``. If ``only`` is false, this also yields distributions that are "in" or "under" ``path_item``, but would not be importable unless their locations were also added to ``sys.path``. ``get_distribution(dist_spec)`` Return a ``Distribution`` object for a given ``Requirement`` or string. If ``dist_spec`` is already a ``Distribution`` instance, it is returned. If it is a ``Requirement`` object or a string that can be parsed into one, it is used to locate and activate a matching distribution, which is then returned. However, if you're creating specialized tools for working with distributions, or creating a new distribution format, you may also need to create ``Distribution`` objects directly, using one of the three constructors below. These constructors all take an optional ``metadata`` argument, which is used to access any resources or metadata associated with the distribution. ``metadata`` must be an object that implements the ``IResourceProvider`` interface, or None. If it is None, an ``EmptyProvider`` is used instead. ``Distribution`` objects implement both the `IResourceProvider`_ and `IMetadataProvider Methods`_ by delegating them to the ``metadata`` object. ``Distribution.from_location(location, basename, metadata=None, **kw)`` (classmethod) Create a distribution for ``location``, which must be a string such as a URL, filename, or other string that might be used on ``sys.path``. ``basename`` is a string naming the distribution, like ``Foo-1.2-py2.4.egg``. If ``basename`` ends with ``.egg``, then the project's name, version, python version and platform are extracted from the filename and used to set those properties of the created distribution. Any additional keyword arguments are forwarded to the ``Distribution()`` constructor. ``Distribution.from_filename(filename, metadata=None**kw)`` (classmethod) Create a distribution by parsing a local filename. This is a shorter way of saying ``Distribution.from_location(normalize_path(filename), os.path.basename(filename), metadata)``. In other words, it creates a distribution whose location is the normalize form of the filename, parsing name and version information from the base portion of the filename. Any additional keyword arguments are forwarded to the ``Distribution()`` constructor. ``Distribution(location,metadata,project_name,version,py_version,platform,precedence)`` Create a distribution by setting its properties. All arguments are optional and default to None, except for ``py_version`` (which defaults to the current Python version) and ``precedence`` (which defaults to ``EGG_DIST``; for more details see ``precedence`` under `Distribution Attributes`_ below). Note that it's usually easier to use the ``from_filename()`` or ``from_location()`` constructors than to specify all these arguments individually. ``Distribution`` Attributes --------------------------- location A string indicating the distribution's location. For an importable distribution, this is the string that would be added to ``sys.path`` to make it actively importable. For non-importable distributions, this is simply a filename, URL, or other way of locating the distribution. project_name A string, naming the project that this distribution is for. Project names are defined by a project's setup script, and they are used to identify projects on PyPI. When a ``Distribution`` is constructed, the ``project_name`` argument is passed through the ``safe_name()`` utility function to filter out any unacceptable characters. key ``dist.key`` is short for ``dist.project_name.lower()``. It's used for case-insensitive comparison and indexing of distributions by project name. extras A list of strings, giving the names of extra features defined by the project's dependency list (the ``extras_require`` argument specified in the project's setup script). version A string denoting what release of the project this distribution contains. When a ``Distribution`` is constructed, the ``version`` argument is passed through the ``safe_version()`` utility function to filter out any unacceptable characters. If no ``version`` is specified at construction time, then attempting to access this attribute later will cause the ``Distribution`` to try to discover its version by reading its ``PKG-INFO`` metadata file. If ``PKG-INFO`` is unavailable or can't be parsed, ``ValueError`` is raised. parsed_version The ``parsed_version`` is an object representing a "parsed" form of the distribution's ``version``. ``dist.parsed_version`` is a shortcut for calling ``parse_version(dist.version)``. It is used to compare or sort distributions by version. (See the `Parsing Utilities`_ section below for more information on the ``parse_version()`` function.) Note that accessing ``parsed_version`` may result in a ``ValueError`` if the ``Distribution`` was constructed without a ``version`` and without ``metadata`` capable of supplying the missing version info. py_version The major/minor Python version the distribution supports, as a string. For example, "2.7" or "3.4". The default is the current version of Python. platform A string representing the platform the distribution is intended for, or ``None`` if the distribution is "pure Python" and therefore cross-platform. See `Platform Utilities`_ below for more information on platform strings. precedence A distribution's ``precedence`` is used to determine the relative order of two distributions that have the same ``project_name`` and ``parsed_version``. The default precedence is ``pkg_resources.EGG_DIST``, which is the highest (i.e. most preferred) precedence. The full list of predefined precedences, from most preferred to least preferred, is: ``EGG_DIST``, ``BINARY_DIST``, ``SOURCE_DIST``, ``CHECKOUT_DIST``, and ``DEVELOP_DIST``. Normally, precedences other than ``EGG_DIST`` are used only by the ``setuptools.package_index`` module, when sorting distributions found in a package index to determine their suitability for installation. "System" and "Development" eggs (i.e., ones that use the ``.egg-info`` format), however, are automatically given a precedence of ``DEVELOP_DIST``. ``Distribution`` Methods ------------------------ ``activate(path=None)`` Ensure distribution is importable on ``path``. If ``path`` is None, ``sys.path`` is used instead. This ensures that the distribution's ``location`` is in the ``path`` list, and it also performs any necessary namespace package fixups or declarations. (That is, if the distribution contains namespace packages, this method ensures that they are declared, and that the distribution's contents for those namespace packages are merged with the contents provided by any other active distributions. See the section above on `Namespace Package Support`_ for more information.) ``pkg_resources`` adds a notification callback to the global ``working_set`` that ensures this method is called whenever a distribution is added to it. Therefore, you should not normally need to explicitly call this method. (Note that this means that namespace packages on ``sys.path`` are always imported as soon as ``pkg_resources`` is, which is another reason why namespace packages should not contain any code or import statements.) ``as_requirement()`` Return a ``Requirement`` instance that matches this distribution's project name and version. ``requires(extras=())`` List the ``Requirement`` objects that specify this distribution's dependencies. If ``extras`` is specified, it should be a sequence of names of "extras" defined by the distribution, and the list returned will then include any dependencies needed to support the named "extras". ``clone(**kw)`` Create a copy of the distribution. Any supplied keyword arguments override the corresponding argument to the ``Distribution()`` constructor, allowing you to change some of the copied distribution's attributes. ``egg_name()`` Return what this distribution's standard filename should be, not including the ".egg" extension. For example, a distribution for project "Foo" version 1.2 that runs on Python 2.3 for Windows would have an ``egg_name()`` of ``Foo-1.2-py2.3-win32``. Any dashes in the name or version are converted to underscores. (``Distribution.from_location()`` will convert them back when parsing a ".egg" file name.) ``__cmp__(other)``, ``__hash__()`` Distribution objects are hashed and compared on the basis of their parsed version and precedence, followed by their key (lowercase project name), location, Python version, and platform. The following methods are used to access ``EntryPoint`` objects advertised by the distribution. See the section above on `Entry Points`_ for more detailed information about these operations: ``get_entry_info(group, name)`` Return the ``EntryPoint`` object for ``group`` and ``name``, or None if no such point is advertised by this distribution. ``get_entry_map(group=None)`` Return the entry point map for ``group``. If ``group`` is None, return a dictionary mapping group names to entry point maps for all groups. (An entry point map is a dictionary of entry point names to ``EntryPoint`` objects.) ``load_entry_point(group, name)`` Short for ``get_entry_info(group, name).load()``. Returns the object advertised by the named entry point, or raises ``ImportError`` if the entry point isn't advertised by this distribution, or there is some other import problem. In addition to the above methods, ``Distribution`` objects also implement all of the `IResourceProvider`_ and `IMetadataProvider Methods`_ (which are documented in later sections): * ``has_metadata(name)`` * ``metadata_isdir(name)`` * ``metadata_listdir(name)`` * ``get_metadata(name)`` * ``get_metadata_lines(name)`` * ``run_script(script_name, namespace)`` * ``get_resource_filename(manager, resource_name)`` * ``get_resource_stream(manager, resource_name)`` * ``get_resource_string(manager, resource_name)`` * ``has_resource(resource_name)`` * ``resource_isdir(resource_name)`` * ``resource_listdir(resource_name)`` If the distribution was created with a ``metadata`` argument, these resource and metadata access methods are all delegated to that ``metadata`` provider. Otherwise, they are delegated to an ``EmptyProvider``, so that the distribution will appear to have no resources or metadata. This delegation approach is used so that supporting custom importers or new distribution formats can be done simply by creating an appropriate `IResourceProvider`_ implementation; see the section below on `Supporting Custom Importers`_ for more details. .. _ResourceManager API: ``ResourceManager`` API ======================= The ``ResourceManager`` class provides uniform access to package resources, whether those resources exist as files and directories or are compressed in an archive of some kind. Normally, you do not need to create or explicitly manage ``ResourceManager`` instances, as the ``pkg_resources`` module creates a global instance for you, and makes most of its methods available as top-level names in the ``pkg_resources`` module namespace. So, for example, this code actually calls the ``resource_string()`` method of the global ``ResourceManager``:: import pkg_resources my_data = pkg_resources.resource_string(__name__, "foo.dat") Thus, you can use the APIs below without needing an explicit ``ResourceManager`` instance; just import and use them as needed. Basic Resource Access --------------------- In the following methods, the ``package_or_requirement`` argument may be either a Python package/module name (e.g. ``foo.bar``) or a ``Requirement`` instance. If it is a package or module name, the named module or package must be importable (i.e., be in a distribution or directory on ``sys.path``), and the ``resource_name`` argument is interpreted relative to the named package. (Note that if a module name is used, then the resource name is relative to the package immediately containing the named module. Also, you should not use use a namespace package name, because a namespace package can be spread across multiple distributions, and is therefore ambiguous as to which distribution should be searched for the resource.) If it is a ``Requirement``, then the requirement is automatically resolved (searching the current ``Environment`` if necessary) and a matching distribution is added to the ``WorkingSet`` and ``sys.path`` if one was not already present. (Unless the ``Requirement`` can't be satisfied, in which case an exception is raised.) The ``resource_name`` argument is then interpreted relative to the root of the identified distribution; i.e. its first path segment will be treated as a peer of the top-level modules or packages in the distribution. Note that resource names must be ``/``-separated paths rooted at the package, cannot contain relative names like ``".."``, and cannot be absolute. Do *not* use ``os.path`` routines to manipulate resource paths, as they are *not* filesystem paths. ``resource_exists(package_or_requirement, resource_name)`` Does the named resource exist? Return ``True`` or ``False`` accordingly. ``resource_stream(package_or_requirement, resource_name)`` Return a readable file-like object for the specified resource; it may be an actual file, a ``StringIO``, or some similar object. The stream is in "binary mode", in the sense that whatever bytes are in the resource will be read as-is. ``resource_string(package_or_requirement, resource_name)`` Return the specified resource as ``bytes``. The resource is read in binary fashion, such that the returned string contains exactly the bytes that are stored in the resource. ``resource_isdir(package_or_requirement, resource_name)`` Is the named resource a directory? Return ``True`` or ``False`` accordingly. ``resource_listdir(package_or_requirement, resource_name)`` List the contents of the named resource directory, just like ``os.listdir`` except that it works even if the resource is in a zipfile. Note that only ``resource_exists()`` and ``resource_isdir()`` are insensitive as to the resource type. You cannot use ``resource_listdir()`` on a file resource, and you can't use ``resource_string()`` or ``resource_stream()`` on directory resources. Using an inappropriate method for the resource type may result in an exception or undefined behavior, depending on the platform and distribution format involved. Resource Extraction ------------------- ``resource_filename(package_or_requirement, resource_name)`` Sometimes, it is not sufficient to access a resource in string or stream form, and a true filesystem filename is needed. In such cases, you can use this method (or module-level function) to obtain a filename for a resource. If the resource is in an archive distribution (such as a zipped egg), it will be extracted to a cache directory, and the filename within the cache will be returned. If the named resource is a directory, then all resources within that directory (including subdirectories) are also extracted. If the named resource is a C extension or "eager resource" (see the ``setuptools`` documentation for details), then all C extensions and eager resources are extracted at the same time. Archived resources are extracted to a cache location that can be managed by the following two methods: ``set_extraction_path(path)`` Set the base path where resources will be extracted to, if needed. If you do not call this routine before any extractions take place, the path defaults to the return value of ``get_default_cache()``. (Which is based on the ``PYTHON_EGG_CACHE`` environment variable, with various platform-specific fallbacks. See that routine's documentation for more details.) Resources are extracted to subdirectories of this path based upon information given by the resource provider. You may set this to a temporary directory, but then you must call ``cleanup_resources()`` to delete the extracted files when done. There is no guarantee that ``cleanup_resources()`` will be able to remove all extracted files. (On Windows, for example, you can't unlink .pyd or .dll files that are still in use.) Note that you may not change the extraction path for a given resource manager once resources have been extracted, unless you first call ``cleanup_resources()``. ``cleanup_resources(force=False)`` Delete all extracted resource files and directories, returning a list of the file and directory names that could not be successfully removed. This function does not have any concurrency protection, so it should generally only be called when the extraction path is a temporary directory exclusive to a single process. This method is not automatically called; you must call it explicitly or register it as an ``atexit`` function if you wish to ensure cleanup of a temporary directory used for extractions. "Provider" Interface -------------------- If you are implementing an ``IResourceProvider`` and/or ``IMetadataProvider`` for a new distribution archive format, you may need to use the following ``IResourceManager`` methods to coordinate extraction of resources to the filesystem. If you're not implementing an archive format, however, you have no need to use these methods. Unlike the other methods listed above, they are *not* available as top-level functions tied to the global ``ResourceManager``; you must therefore have an explicit ``ResourceManager`` instance to use them. ``get_cache_path(archive_name, names=())`` Return absolute location in cache for ``archive_name`` and ``names`` The parent directory of the resulting path will be created if it does not already exist. ``archive_name`` should be the base filename of the enclosing egg (which may not be the name of the enclosing zipfile!), including its ".egg" extension. ``names``, if provided, should be a sequence of path name parts "under" the egg's extraction location. This method should only be called by resource providers that need to obtain an extraction location, and only for names they intend to extract, as it tracks the generated names for possible cleanup later. ``extraction_error()`` Raise an ``ExtractionError`` describing the active exception as interfering with the extraction process. You should call this if you encounter any OS errors extracting the file to the cache path; it will format the operating system exception for you, and add other information to the ``ExtractionError`` instance that may be needed by programs that want to wrap or handle extraction errors themselves. ``postprocess(tempname, filename)`` Perform any platform-specific postprocessing of ``tempname``. Resource providers should call this method ONLY after successfully extracting a compressed resource. They must NOT call it on resources that are already in the filesystem. ``tempname`` is the current (temporary) name of the file, and ``filename`` is the name it will be renamed to by the caller after this routine returns. Metadata API ============ The metadata API is used to access metadata resources bundled in a pluggable distribution. Metadata resources are virtual files or directories containing information about the distribution, such as might be used by an extensible application or framework to connect "plugins". Like other kinds of resources, metadata resource names are ``/``-separated and should not contain ``..`` or begin with a ``/``. You should not use ``os.path`` routines to manipulate resource paths. The metadata API is provided by objects implementing the ``IMetadataProvider`` or ``IResourceProvider`` interfaces. ``Distribution`` objects implement this interface, as do objects returned by the ``get_provider()`` function: ``get_provider(package_or_requirement)`` If a package name is supplied, return an ``IResourceProvider`` for the package. If a ``Requirement`` is supplied, resolve it by returning a ``Distribution`` from the current working set (searching the current ``Environment`` if necessary and adding the newly found ``Distribution`` to the working set). If the named package can't be imported, or the ``Requirement`` can't be satisfied, an exception is raised. NOTE: if you use a package name rather than a ``Requirement``, the object you get back may not be a pluggable distribution, depending on the method by which the package was installed. In particular, "development" packages and "single-version externally-managed" packages do not have any way to map from a package name to the corresponding project's metadata. Do not write code that passes a package name to ``get_provider()`` and then tries to retrieve project metadata from the returned object. It may appear to work when the named package is in an ``.egg`` file or directory, but it will fail in other installation scenarios. If you want project metadata, you need to ask for a *project*, not a package. ``IMetadataProvider`` Methods ----------------------------- The methods provided by objects (such as ``Distribution`` instances) that implement the ``IMetadataProvider`` or ``IResourceProvider`` interfaces are: ``has_metadata(name)`` Does the named metadata resource exist? ``metadata_isdir(name)`` Is the named metadata resource a directory? ``metadata_listdir(name)`` List of metadata names in the directory (like ``os.listdir()``) ``get_metadata(name)`` Return the named metadata resource as a string. The data is read in binary mode; i.e., the exact bytes of the resource file are returned. ``get_metadata_lines(name)`` Yield named metadata resource as list of non-blank non-comment lines. This is short for calling ``yield_lines(provider.get_metadata(name))``. See the section on `yield_lines()`_ below for more information on the syntax it recognizes. ``run_script(script_name, namespace)`` Execute the named script in the supplied namespace dictionary. Raises ``ResolutionError`` if there is no script by that name in the ``scripts`` metadata directory. ``namespace`` should be a Python dictionary, usually a module dictionary if the script is being run as a module. Exceptions ========== ``pkg_resources`` provides a simple exception hierarchy for problems that may occur when processing requests to locate and activate packages:: ResolutionError DistributionNotFound VersionConflict UnknownExtra ExtractionError ``ResolutionError`` This class is used as a base class for the other three exceptions, so that you can catch all of them with a single "except" clause. It is also raised directly for miscellaneous requirement-resolution problems like trying to run a script that doesn't exist in the distribution it was requested from. ``DistributionNotFound`` A distribution needed to fulfill a requirement could not be found. ``VersionConflict`` The requested version of a project conflicts with an already-activated version of the same project. ``UnknownExtra`` One of the "extras" requested was not recognized by the distribution it was requested from. ``ExtractionError`` A problem occurred extracting a resource to the Python Egg cache. The following attributes are available on instances of this exception: manager The resource manager that raised this exception cache_path The base directory for resource extraction original_error The exception instance that caused extraction to fail Supporting Custom Importers =========================== By default, ``pkg_resources`` supports normal filesystem imports, and ``zipimport`` importers. If you wish to use the ``pkg_resources`` features with other (PEP 302-compatible) importers or module loaders, you may need to register various handlers and support functions using these APIs: ``register_finder(importer_type, distribution_finder)`` Register ``distribution_finder`` to find distributions in ``sys.path`` items. ``importer_type`` is the type or class of a PEP 302 "Importer" (``sys.path`` item handler), and ``distribution_finder`` is a callable that, when passed a path item, the importer instance, and an ``only`` flag, yields ``Distribution`` instances found under that path item. (The ``only`` flag, if true, means the finder should yield only ``Distribution`` objects whose ``location`` is equal to the path item provided.) See the source of the ``pkg_resources.find_on_path`` function for an example finder function. ``register_loader_type(loader_type, provider_factory)`` Register ``provider_factory`` to make ``IResourceProvider`` objects for ``loader_type``. ``loader_type`` is the type or class of a PEP 302 ``module.__loader__``, and ``provider_factory`` is a function that, when passed a module object, returns an `IResourceProvider`_ for that module, allowing it to be used with the `ResourceManager API`_. ``register_namespace_handler(importer_type, namespace_handler)`` Register ``namespace_handler`` to declare namespace packages for the given ``importer_type``. ``importer_type`` is the type or class of a PEP 302 "importer" (sys.path item handler), and ``namespace_handler`` is a callable with a signature like this:: def namespace_handler(importer, path_entry, moduleName, module): # return a path_entry to use for child packages Namespace handlers are only called if the relevant importer object has already agreed that it can handle the relevant path item. The handler should only return a subpath if the module ``__path__`` does not already contain an equivalent subpath. Otherwise, it should return None. For an example namespace handler, see the source of the ``pkg_resources.file_ns_handler`` function, which is used for both zipfile importing and regular importing. IResourceProvider ----------------- ``IResourceProvider`` is an abstract class that documents what methods are required of objects returned by a ``provider_factory`` registered with ``register_loader_type()``. ``IResourceProvider`` is a subclass of ``IMetadataProvider``, so objects that implement this interface must also implement all of the `IMetadataProvider Methods`_ as well as the methods shown here. The ``manager`` argument to the methods below must be an object that supports the full `ResourceManager API`_ documented above. ``get_resource_filename(manager, resource_name)`` Return a true filesystem path for ``resource_name``, coordinating the extraction with ``manager``, if the resource must be unpacked to the filesystem. ``get_resource_stream(manager, resource_name)`` Return a readable file-like object for ``resource_name``. ``get_resource_string(manager, resource_name)`` Return a string containing the contents of ``resource_name``. ``has_resource(resource_name)`` Does the package contain the named resource? ``resource_isdir(resource_name)`` Is the named resource a directory? Return a false value if the resource does not exist or is not a directory. ``resource_listdir(resource_name)`` Return a list of the contents of the resource directory, ala ``os.listdir()``. Requesting the contents of a non-existent directory may raise an exception. Note, by the way, that your provider classes need not (and should not) subclass ``IResourceProvider`` or ``IMetadataProvider``! These classes exist solely for documentation purposes and do not provide any useful implementation code. You may instead wish to subclass one of the `built-in resource providers`_. Built-in Resource Providers --------------------------- ``pkg_resources`` includes several provider classes that are automatically used where appropriate. Their inheritance tree looks like this:: NullProvider EggProvider DefaultProvider PathMetadata ZipProvider EggMetadata EmptyProvider FileMetadata ``NullProvider`` This provider class is just an abstract base that provides for common provider behaviors (such as running scripts), given a definition for just a few abstract methods. ``EggProvider`` This provider class adds in some egg-specific features that are common to zipped and unzipped eggs. ``DefaultProvider`` This provider class is used for unpacked eggs and "plain old Python" filesystem modules. ``ZipProvider`` This provider class is used for all zipped modules, whether they are eggs or not. ``EmptyProvider`` This provider class always returns answers consistent with a provider that has no metadata or resources. ``Distribution`` objects created without a ``metadata`` argument use an instance of this provider class instead. Since all ``EmptyProvider`` instances are equivalent, there is no need to have more than one instance. ``pkg_resources`` therefore creates a global instance of this class under the name ``empty_provider``, and you may use it if you have need of an ``EmptyProvider`` instance. ``PathMetadata(path, egg_info)`` Create an ``IResourceProvider`` for a filesystem-based distribution, where ``path`` is the filesystem location of the importable modules, and ``egg_info`` is the filesystem location of the distribution's metadata directory. ``egg_info`` should usually be the ``EGG-INFO`` subdirectory of ``path`` for an "unpacked egg", and a ``ProjectName.egg-info`` subdirectory of ``path`` for a "development egg". However, other uses are possible for custom purposes. ``EggMetadata(zipimporter)`` Create an ``IResourceProvider`` for a zipfile-based distribution. The ``zipimporter`` should be a ``zipimport.zipimporter`` instance, and may represent a "basket" (a zipfile containing multiple ".egg" subdirectories) a specific egg *within* a basket, or a zipfile egg (where the zipfile itself is a ".egg"). It can also be a combination, such as a zipfile egg that also contains other eggs. ``FileMetadata(path_to_pkg_info)`` Create an ``IResourceProvider`` that provides exactly one metadata resource: ``PKG-INFO``. The supplied path should be a distutils PKG-INFO file. This is basically the same as an ``EmptyProvider``, except that requests for ``PKG-INFO`` will be answered using the contents of the designated file. (This provider is used to wrap ``.egg-info`` files installed by vendor-supplied system packages.) Utility Functions ================= In addition to its high-level APIs, ``pkg_resources`` also includes several generally-useful utility routines. These routines are used to implement the high-level APIs, but can also be quite useful by themselves. Parsing Utilities ----------------- ``parse_version(version)`` Parsed a project's version string as defined by PEP 440. The returned value will be an object that represents the version. These objects may be compared to each other and sorted. The sorting algorithm is as defined by PEP 440 with the addition that any version which is not a valid PEP 440 version will be considered less than any valid PEP 440 version and the invalid versions will continue sorting using the original algorithm. .. _yield_lines(): ``yield_lines(strs)`` Yield non-empty/non-comment lines from a string/unicode or a possibly-nested sequence thereof. If ``strs`` is an instance of ``basestring``, it is split into lines, and each non-blank, non-comment line is yielded after stripping leading and trailing whitespace. (Lines whose first non-blank character is ``#`` are considered comment lines.) If ``strs`` is not an instance of ``basestring``, it is iterated over, and each item is passed recursively to ``yield_lines()``, so that an arbitrarily nested sequence of strings, or sequences of sequences of strings can be flattened out to the lines contained therein. So for example, passing a file object or a list of strings to ``yield_lines`` will both work. (Note that between each string in a sequence of strings there is assumed to be an implicit line break, so lines cannot bridge two strings in a sequence.) This routine is used extensively by ``pkg_resources`` to parse metadata and file formats of various kinds, and most other ``pkg_resources`` parsing functions that yield multiple values will use it to break up their input. However, this routine is idempotent, so calling ``yield_lines()`` on the output of another call to ``yield_lines()`` is completely harmless. ``split_sections(strs)`` Split a string (or possibly-nested iterable thereof), yielding ``(section, content)`` pairs found using an ``.ini``-like syntax. Each ``section`` is a whitespace-stripped version of the section name ("``[section]``") and each ``content`` is a list of stripped lines excluding blank lines and comment-only lines. If there are any non-blank, non-comment lines before the first section header, they're yielded in a first ``section`` of ``None``. This routine uses ``yield_lines()`` as its front end, so you can pass in anything that ``yield_lines()`` accepts, such as an open text file, string, or sequence of strings. ``ValueError`` is raised if a malformed section header is found (i.e. a line starting with ``[`` but not ending with ``]``). Note that this simplistic parser assumes that any line whose first nonblank character is ``[`` is a section heading, so it can't support .ini format variations that allow ``[`` as the first nonblank character on other lines. ``safe_name(name)`` Return a "safe" form of a project's name, suitable for use in a ``Requirement`` string, as a distribution name, or a PyPI project name. All non-alphanumeric runs are condensed to single "-" characters, such that a name like "The $$$ Tree" becomes "The-Tree". Note that if you are generating a filename from this value you should combine it with a call to ``to_filename()`` so all dashes ("-") are replaced by underscores ("_"). See ``to_filename()``. ``safe_version(version)`` This will return the normalized form of any PEP 440 version. If the version string is not PEP 440 compatible, this function behaves similar to ``safe_name()`` except that spaces in the input become dots, and dots are allowed to exist in the output. As with ``safe_name()``, if you are generating a filename from this you should replace any "-" characters in the output with underscores. ``safe_extra(extra)`` Return a "safe" form of an extra's name, suitable for use in a requirement string or a setup script's ``extras_require`` keyword. This routine is similar to ``safe_name()`` except that non-alphanumeric runs are replaced by a single underbar (``_``), and the result is lowercased. ``to_filename(name_or_version)`` Escape a name or version string so it can be used in a dash-separated filename (or ``#egg=name-version`` tag) without ambiguity. You should only pass in values that were returned by ``safe_name()`` or ``safe_version()``. Platform Utilities ------------------ ``get_build_platform()`` Return this platform's identifier string. For Windows, the return value is ``"win32"``, and for macOS it is a string of the form ``"macosx-10.4-ppc"``. All other platforms return the same uname-based string that the ``distutils.util.get_platform()`` function returns. This string is the minimum platform version required by distributions built on the local machine. (Backward compatibility note: setuptools versions prior to 0.6b1 called this function ``get_platform()``, and the function is still available under that name for backward compatibility reasons.) ``get_supported_platform()`` (New in 0.6b1) This is the similar to ``get_build_platform()``, but is the maximum platform version that the local machine supports. You will usually want to use this value as the ``provided`` argument to the ``compatible_platforms()`` function. ``compatible_platforms(provided, required)`` Return true if a distribution built on the ``provided`` platform may be used on the ``required`` platform. If either platform value is ``None``, it is considered a wildcard, and the platforms are therefore compatible. Likewise, if the platform strings are equal, they're also considered compatible, and ``True`` is returned. Currently, the only non-equal platform strings that are considered compatible are macOS platform strings with the same hardware type (e.g. ``ppc``) and major version (e.g. ``10``) with the ``provided`` platform's minor version being less than or equal to the ``required`` platform's minor version. ``get_default_cache()`` Determine the default cache location for extracting resources from zipped eggs. This routine returns the ``PYTHON_EGG_CACHE`` environment variable, if set. Otherwise, on Windows, it returns a "Python-Eggs" subdirectory of the user's "Application Data" directory. On all other systems, it returns ``os.path.expanduser("~/.python-eggs")`` if ``PYTHON_EGG_CACHE`` is not set. PEP 302 Utilities ----------------- ``get_importer(path_item)`` A deprecated alias for ``pkgutil.get_importer()`` File/Path Utilities ------------------- ``ensure_directory(path)`` Ensure that the parent directory (``os.path.dirname``) of ``path`` actually exists, using ``os.makedirs()`` if necessary. ``normalize_path(path)`` Return a "normalized" version of ``path``, such that two paths represent the same filesystem location if they have equal ``normalized_path()`` values. Specifically, this is a shortcut for calling ``os.path.realpath`` and ``os.path.normcase`` on ``path``. Unfortunately, on certain platforms (notably Cygwin and macOS) the ``normcase`` function does not accurately reflect the platform's case-sensitivity, so there is always the possibility of two apparently-different paths being equal on such platforms. History ------- 0.6c9 * Fix ``resource_listdir('')`` always returning an empty list for zipped eggs. 0.6c7 * Fix package precedence problem where single-version eggs installed in ``site-packages`` would take precedence over ``.egg`` files (or directories) installed in ``site-packages``. 0.6c6 * Fix extracted C extensions not having executable permissions under Cygwin. * Allow ``.egg-link`` files to contain relative paths. * Fix cache dir defaults on Windows when multiple environment vars are needed to construct a path. 0.6c4 * Fix "dev" versions being considered newer than release candidates. 0.6c3 * Python 2.5 compatibility fixes. 0.6c2 * Fix a problem with eggs specified directly on ``PYTHONPATH`` on case-insensitive filesystems possibly not showing up in the default working set, due to differing normalizations of ``sys.path`` entries. 0.6b3 * Fixed a duplicate path insertion problem on case-insensitive filesystems. 0.6b1 * Split ``get_platform()`` into ``get_supported_platform()`` and ``get_build_platform()`` to work around a Mac versioning problem that caused the behavior of ``compatible_platforms()`` to be platform specific. * Fix entry point parsing when a standalone module name has whitespace between it and the extras. 0.6a11 * Added ``ExtractionError`` and ``ResourceManager.extraction_error()`` so that cache permission problems get a more user-friendly explanation of the problem, and so that programs can catch and handle extraction errors if they need to. 0.6a10 * Added the ``extras`` attribute to ``Distribution``, the ``find_plugins()`` method to ``WorkingSet``, and the ``__add__()`` and ``__iadd__()`` methods to ``Environment``. * ``safe_name()`` now allows dots in project names. * There is a new ``to_filename()`` function that escapes project names and versions for safe use in constructing egg filenames from a Distribution object's metadata. * Added ``Distribution.clone()`` method, and keyword argument support to other ``Distribution`` constructors. * Added the ``DEVELOP_DIST`` precedence, and automatically assign it to eggs using ``.egg-info`` format. 0.6a9 * Don't raise an error when an invalid (unfinished) distribution is found unless absolutely necessary. Warn about skipping invalid/unfinished eggs when building an Environment. * Added support for ``.egg-info`` files or directories with version/platform information embedded in the filename, so that system packagers have the option of including ``PKG-INFO`` files to indicate the presence of a system-installed egg, without needing to use ``.egg`` directories, zipfiles, or ``.pth`` manipulation. * Changed ``parse_version()`` to remove dashes before pre-release tags, so that ``0.2-rc1`` is considered an *older* version than ``0.2``, and is equal to ``0.2rc1``. The idea that a dash *always* meant a post-release version was highly non-intuitive to setuptools users and Python developers, who seem to want to use ``-rc`` version numbers a lot. 0.6a8 * Fixed a problem with ``WorkingSet.resolve()`` that prevented version conflicts from being detected at runtime. * Improved runtime conflict warning message to identify a line in the user's program, rather than flagging the ``warn()`` call in ``pkg_resources``. * Avoid giving runtime conflict warnings for namespace packages, even if they were declared by a different package than the one currently being activated. * Fix path insertion algorithm for case-insensitive filesystems. * Fixed a problem with nested namespace packages (e.g. ``peak.util``) not being set as an attribute of their parent package. 0.6a6 * Activated distributions are now inserted in ``sys.path`` (and the working set) just before the directory that contains them, instead of at the end. This allows e.g. eggs in ``site-packages`` to override unmanaged modules in the same location, and allows eggs found earlier on ``sys.path`` to override ones found later. * When a distribution is activated, it now checks whether any contained non-namespace modules have already been imported and issues a warning if a conflicting module has already been imported. * Changed dependency processing so that it's breadth-first, allowing a depender's preferences to override those of a dependee, to prevent conflicts when a lower version is acceptable to the dependee, but not the depender. * Fixed a problem extracting zipped files on Windows, when the egg in question has had changed contents but still has the same version number. 0.6a4 * Fix a bug in ``WorkingSet.resolve()`` that was introduced in 0.6a3. 0.6a3 * Added ``safe_extra()`` parsing utility routine, and use it for Requirement, EntryPoint, and Distribution objects' extras handling. 0.6a1 * Enhanced performance of ``require()`` and related operations when all requirements are already in the working set, and enhanced performance of directory scanning for distributions. * Fixed some problems using ``pkg_resources`` w/PEP 302 loaders other than ``zipimport``, and the previously-broken "eager resource" support. * Fixed ``pkg_resources.resource_exists()`` not working correctly, along with some other resource API bugs. * Many API changes and enhancements: * Added ``EntryPoint``, ``get_entry_map``, ``load_entry_point``, and ``get_entry_info`` APIs for dynamic plugin discovery. * ``list_resources`` is now ``resource_listdir`` (and it actually works) * Resource API functions like ``resource_string()`` that accepted a package name and resource name, will now also accept a ``Requirement`` object in place of the package name (to allow access to non-package data files in an egg). * ``get_provider()`` will now accept a ``Requirement`` instance or a module name. If it is given a ``Requirement``, it will return a corresponding ``Distribution`` (by calling ``require()`` if a suitable distribution isn't already in the working set), rather than returning a metadata and resource provider for a specific module. (The difference is in how resource paths are interpreted; supplying a module name means resources path will be module-relative, rather than relative to the distribution's root.) * ``Distribution`` objects now implement the ``IResourceProvider`` and ``IMetadataProvider`` interfaces, so you don't need to reference the (no longer available) ``metadata`` attribute to get at these interfaces. * ``Distribution`` and ``Requirement`` both have a ``project_name`` attribute for the project name they refer to. (Previously these were ``name`` and ``distname`` attributes.) * The ``path`` attribute of ``Distribution`` objects is now ``location``, because it isn't necessarily a filesystem path (and hasn't been for some time now). The ``location`` of ``Distribution`` objects in the filesystem should always be normalized using ``pkg_resources.normalize_path()``; all of the setuptools' code that generates distributions from the filesystem (including ``Distribution.from_filename()``) ensure this invariant, but if you use a more generic API like ``Distribution()`` or ``Distribution.from_location()`` you should take care that you don't create a distribution with an un-normalized filesystem path. * ``Distribution`` objects now have an ``as_requirement()`` method that returns a ``Requirement`` for the distribution's project name and version. * Distribution objects no longer have an ``installed_on()`` method, and the ``install_on()`` method is now ``activate()`` (but may go away altogether soon). The ``depends()`` method has also been renamed to ``requires()``, and ``InvalidOption`` is now ``UnknownExtra``. * ``find_distributions()`` now takes an additional argument called ``only``, that tells it to only yield distributions whose location is the passed-in path. (It defaults to False, so that the default behavior is unchanged.) * ``AvailableDistributions`` is now called ``Environment``, and the ``get()``, ``__len__()``, and ``__contains__()`` methods were removed, because they weren't particularly useful. ``__getitem__()`` no longer raises ``KeyError``; it just returns an empty list if there are no distributions for the named project. * The ``resolve()`` method of ``Environment`` is now a method of ``WorkingSet`` instead, and the ``best_match()`` method now uses a working set instead of a path list as its second argument. * There is a new ``pkg_resources.add_activation_listener()`` API that lets you register a callback for notifications about distributions added to ``sys.path`` (including the distributions already on it). This is basically a hook for extensible applications and frameworks to be able to search for plugin metadata in distributions added at runtime. 0.5a13 * Fixed a bug in resource extraction from nested packages in a zipped egg. 0.5a12 * Updated extraction/cache mechanism for zipped resources to avoid inter-process and inter-thread races during extraction. The default cache location can now be set via the ``PYTHON_EGGS_CACHE`` environment variable, and the default Windows cache is now a ``Python-Eggs`` subdirectory of the current user's "Application Data" directory, if the ``PYTHON_EGGS_CACHE`` variable isn't set. 0.5a10 * Fix a problem with ``pkg_resources`` being confused by non-existent eggs on ``sys.path`` (e.g. if a user deletes an egg without removing it from the ``easy-install.pth`` file). * Fix a problem with "basket" support in ``pkg_resources``, where egg-finding never actually went inside ``.egg`` files. * Made ``pkg_resources`` import the module you request resources from, if it's not already imported. 0.5a4 * ``pkg_resources.AvailableDistributions.resolve()`` and related methods now accept an ``installer`` argument: a callable taking one argument, a ``Requirement`` instance. The callable must return a ``Distribution`` object, or ``None`` if no distribution is found. This feature is used by EasyInstall to resolve dependencies by recursively invoking itself. 0.4a4 * Fix problems with ``resource_listdir()``, ``resource_isdir()`` and resource directory extraction for zipped eggs. 0.4a3 * Fixed scripts not being able to see a ``__file__`` variable in ``__main__`` * Fixed a problem with ``resource_isdir()`` implementation that was introduced in 0.4a2. 0.4a1 * Fixed a bug in requirements processing for exact versions (i.e. ``==`` and ``!=``) when only one condition was included. * Added ``safe_name()`` and ``safe_version()`` APIs to clean up handling of arbitrary distribution names and versions found on PyPI. 0.3a4 * ``pkg_resources`` now supports resource directories, not just the resources in them. In particular, there are ``resource_listdir()`` and ``resource_isdir()`` APIs. * ``pkg_resources`` now supports "egg baskets" -- .egg zipfiles which contain multiple distributions in subdirectories whose names end with ``.egg``. Having such a "basket" in a directory on ``sys.path`` is equivalent to having the individual eggs in that directory, but the contained eggs can be individually added (or not) to ``sys.path``. Currently, however, there is no automated way to create baskets. * Namespace package manipulation is now protected by the Python import lock. 0.3a1 * Initial release. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/python 2 sunset.rst0000644000175100001730000000672214467657412020110 0ustar00runnerdocker:orphan: Python 2 Sunset =============== Since January 2020 and the release of Setuptools 45, Python 2 is no longer supported by the most current release (`discussion `_). Setuptools as a project continues to support Python 2 with bugfixes and important features on Setuptools 44.x. By design, most users will be unaffected by this change. That's because Setuptools 45 declares its supported Python versions to exclude Python 2.7, and installers such as pip 9 or later will honor this declaration and prevent installation of Setuptools 45 or later in Python 2 environments. Users that do import any portion of Setuptools 45 or later on Python 2 are directed to this documentation to provide guidance on how to work around the issues. Workarounds ----------- The best recommendation is to avoid Python 2 and move to Python 3 where possible. This project acknowledges that not all environments can drop Python 2 support, so provides other options. In less common scenarios, later versions of Setuptools can be installed on unsupported Python versions. In these environments, the installer is advised to first install ``setuptools<45`` to "pin Setuptools" to a compatible version. - When using older versions of pip (before 9.0), the ``Requires-Python`` directive is not honored and invalid versions can be installed. Users are advised first to upgrade pip and retry or to pin Setuptools. Use ``pip --version`` to determine the version of pip. - When using ``easy_install``, ``Requires-Python`` is not honored and later versions can be installed. In this case, users are advised to pin Setuptools. This applies to ``setup.py install`` invocations as well, as they use Setuptools under the hood. It's still not working ---------------------- If after trying the above steps, the Python environment still has incompatible versions of Setuptools installed, here are some things to try. 1. Uninstall and reinstall Setuptools. Run ``pip uninstall -y setuptools`` for the relevant environment. Repeat until there is no Setuptools installed. Then ``pip install setuptools``. 2. If possible, attempt to replicate the problem in a second environment (virtual machine, friend's computer, etc). If the issue is isolated to just one unique environment, first determine what is different about those environments (or reinstall/reset the failing one to defaults). 3. End users who are not themselves the maintainers for the package they are trying to install should contact the support channels for the relevant application. Please be considerate of those projects by searching for existing issues and following the latest guidance before reaching out for support. When filing an issue, be sure to give as much detail as possible to help the maintainers understand what factors led to the issue after following their recommended guidance. 4. Reach out to your local support groups. There's a good chance someone nearby has the expertise and willingness to help. 5. If all else fails, `file this template `_ with Setuptools. Please complete the whole template, providing as much detail about what factors led to the issue. Setuptools maintainers will summarily close tickets filed without any meaningful detail or engagement with the issue. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4875476 setuptools-68.1.2/docs/references/0000755000175100001730000000000014467657443016527 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/references/keywords.rst0000644000175100001730000004640114467657412021131 0ustar00runnerdocker======== Keywords ======== The following are keywords ``setuptools.setup()`` accepts. They allow configuring the build process for a Python distribution or adding metadata via a ``setup.py`` script placed at the root of your project. All of them are optional; you do not have to supply them unless you need the associated ``setuptools`` feature. Metadata and configuration supplied via ``setup()`` is complementary to (and may be overwritten by) the information present in ``setup.cfg`` and ``pyproject.toml``. Some important metadata, such as ``name`` and ``version``, may assume a default *degenerate* value if not specified. Users are strongly encouraged to use a declarative config either via :doc:`setup.cfg ` or :doc:`pyproject.toml ` and only rely on ``setup.py`` if they need to tap into special behaviour that requires scripting (such as building C extensions). .. note:: When using declarative configs via ``pyproject.toml`` with ``setuptools<64.0.0``, users can still keep a very simple ``setup.py`` just to ensure editable installs are supported, for example:: from setuptools import setup setup() Versions of ``setuptools`` ``>=64.0.0`` do not require this extra minimal ``setup.py`` file. .. _keyword/name: ``name`` A string specifying the name of the package. .. _keyword/version: ``version`` A string specifying the version number of the package. .. _keyword/description: ``description`` A string describing the package in a single line. .. _keyword/long_description: ``long_description`` A string providing a longer description of the package. .. _keyword/long_description_content_type: ``long_description_content_type`` A string specifying the content type is used for the ``long_description`` (e.g. ``text/markdown``) .. _keyword/author: ``author`` A string specifying the author of the package. .. _keyword/author_email: ``author_email`` A string specifying the email address of the package author. .. _keyword/maintainer: ``maintainer`` A string specifying the name of the current maintainer, if different from the author. Note that if the maintainer is provided, setuptools will use it as the author in ``PKG-INFO``. .. _keyword/maintainer_email: ``maintainer_email`` A string specifying the email address of the current maintainer, if different from the author. .. _keyword/url: ``url`` A string specifying the URL for the package homepage. .. _keyword/download_url: ``download_url`` A string specifying the URL to download the package. .. _keyword/packages: ``packages`` A list of strings specifying the packages that setuptools will manipulate. .. _keyword/py_modules: ``py_modules`` A list of strings specifying the modules that setuptools will manipulate. .. _keyword/scripts: ``scripts`` A list of strings specifying the standalone script files to be built and installed. .. _keyword/ext_package: ``ext_package`` A string specifying the base package name for the extensions provided by this package. .. _keyword/ext_modules: ``ext_modules`` A list of instances of ``setuptools.Extension`` providing the list of Python extensions to be built. .. _keyword/classifiers: ``classifiers`` A list of strings describing the categories for the package. .. _keyword/distclass: ``distclass`` A subclass of ``Distribution`` to use. .. _keyword/script_name: ``script_name`` A string specifying the name of the setup.py script -- defaults to ``sys.argv[0]`` .. _keyword/script_args: ``script_args`` A list of strings defining the arguments to supply to the setup script. .. _keyword/options: ``options`` A dictionary providing the default options for the setup script. .. _keyword/license: ``license`` A string specifying the license of the package. .. _keyword/license_file: ``license_file`` .. warning:: ``license_file`` is deprecated. Use ``license_files`` instead. .. _keyword/license_files: ``license_files`` A list of glob patterns for license related files that should be included. If neither ``license_file`` nor ``license_files`` is specified, this option defaults to ``LICEN[CS]E*``, ``COPYING*``, ``NOTICE*``, and ``AUTHORS*``. .. _keyword/keywords: ``keywords`` A list of strings or a comma-separated string providing descriptive meta-data. See: :ref:`Core Metadata Specifications`. .. _keyword/platforms: ``platforms`` A list of strings or comma-separated string. .. _keyword/cmdclass: ``cmdclass`` A dictionary providing a mapping of command names to ``Command`` subclasses. .. _keyword/data_files: ``data_files`` .. warning:: ``data_files`` is deprecated. It does not work with wheels, so it should be avoided. A list of strings specifying the data files to install. .. _keyword/package_dir: ``package_dir`` A dictionary that maps package names (as they will be imported by the end-users) into directory paths (that actually exist in the project's source tree). This configuration has two main purposes: 1. To effectively "rename" paths when building your package. For example, ``package_dir={"mypkg": "dir1/dir2/code_for_mypkg"}`` will instruct setuptools to copy the ``dir1/dir2/code_for_mypkg/...`` files as ``mypkg/...`` when building the final :term:`wheel distribution `. .. attention:: While it is *possible* to specify arbitrary mappings, developers are **STRONGLY ADVISED AGAINST** that. They should try as much as possible to keep the directory names and hierarchy identical to the way they will appear in the final wheel, only deviating when absolutely necessary. 2. To indicate that the relevant code is entirely contained inside a specific directory (instead of directly placed under the project's root). In this case, a special key is required (the empty string, ``""``), for example: ``package_dir={"": ""}``. All the directories inside the container directory will be copied directly into the final :term:`wheel distribution `, but the container directory itself will not. This practice is very common in the community to help separate the package implementation from auxiliary files (e.g. CI configuration files), and is referred to as :ref:`src-layout`, because the container directory is commonly named ``src``. All paths in ``package_dir`` must be relative to the project root directory and use a forward slash (``/``) as path separator regardless of the operating system. .. tip:: When using :doc:`package discovery ` together with :doc:`setup.cfg ` or :doc:`pyproject.toml `, it is very likely that you don't need to specify a value for ``package_dir``. Please have a look at the definitions of :ref:`src-layout` and :ref:`flat-layout` to learn common practices on how to design a project's directory structure and minimise the amount of configuration that is needed. .. _keyword/requires: ``requires`` .. warning:: ``requires`` is superseded by ``install_requires`` and should not be used anymore. .. _keyword/obsoletes: ``obsoletes`` .. warning:: ``obsoletes`` is currently ignored by ``pip``. List of strings describing packages which this package renders obsolete, meaning that the two projects should not be installed at the same time. Version declarations can be supplied. Version numbers must be in the format specified in Version specifiers (e.g. ``foo (<3.0)``). This field may be followed by an environment marker after a semicolon (e.g. ``foo; os_name == "posix"``) The most common use of this field will be in case a project name changes, e.g. Gorgon 2.3 gets subsumed into Torqued Python 1.0. When you install Torqued Python, the Gorgon distribution should be removed. .. _keyword/provides: ``provides`` .. warning:: ``provides`` is currently ignored by ``pip``. List of strings describing package- and virtual package names contained within this package. A package may provide additional names, e.g. to indicate that multiple projects have been bundled together. For instance, source distributions of the ZODB project have historically included the transaction project, which is now available as a separate distribution. Installing such a source distribution satisfies requirements for both ZODB and transaction. A package may also provide a “virtual” project name, which does not correspond to any separately-distributed project: such a name might be used to indicate an abstract capability which could be supplied by one of multiple projects. E.g., multiple projects might supply RDBMS bindings for use by a given ORM: each project might declare that it provides ORM-bindings, allowing other projects to depend only on having at most one of them installed. A version declaration may be supplied and must follow the rules described in Version specifiers. The distribution’s version number will be implied if none is specified (e.g. ``foo (<3.0)``). Each package may be followed by an environment marker after a semicolon (e.g. ``foo; os_name == "posix"``). .. _keyword/include_package_data: ``include_package_data`` If set to ``True``, this tells ``setuptools`` to automatically include any data files it finds inside your package directories that are specified by your ``MANIFEST.in`` file. For more information, see the section on :ref:`Including Data Files`. .. _keyword/exclude_package_data: ``exclude_package_data`` A dictionary mapping package names to lists of glob patterns that should be *excluded* from your package directories. You can use this to trim back any excess files included by ``include_package_data``. For a complete description and examples, see the section on :ref:`Including Data Files`. .. _keyword/package_data: ``package_data`` A dictionary mapping package names to lists of glob patterns. For a complete description and examples, see the section on :ref:`Including Data Files`. You do not need to use this option if you are using ``include_package_data``, unless you need to add e.g. files that are generated by your setup script and build process. (And are therefore not in source control or are files that you don't want to include in your source distribution.) .. _keyword/zip_safe: ``zip_safe`` A boolean (True or False) flag specifying whether the project can be safely installed and run from a zip file. If this argument is not supplied, the ``bdist_egg`` command will have to analyze all of your project's contents for possible problems each time it builds an egg. .. _keyword/install_requires: ``install_requires`` A string or list of strings specifying what other distributions need to be installed when this one is. See the section on :ref:`Declaring Dependencies` for details and examples of the format of this argument. .. _keyword/entry_points: ``entry_points`` A dictionary mapping entry point group names to strings or lists of strings defining the entry points. Entry points are used to support dynamic discovery of services or plugins provided by a project. See :ref:`Dynamic Discovery of Services and Plugins` for details and examples of the format of this argument. In addition, this keyword is used to support :ref:`Automatic Script Creation `. .. _keyword/extras_require: ``extras_require`` A dictionary mapping names of "extras" (optional features of your project) to strings or lists of strings specifying what other distributions must be installed to support those features. See the section on :ref:`Declaring Dependencies` for details and examples of the format of this argument. .. _keyword/python_requires: ``python_requires`` A string corresponding to a version specifier (as defined in PEP 440) for the Python version, used to specify the Requires-Python defined in PEP 345. .. _keyword/setup_requires: ``setup_requires`` .. warning:: Using ``setup_requires`` is discouraged in favor of :pep:`518`. A string or list of strings specifying what other distributions need to be present in order for the *setup script* to run. ``setuptools`` will attempt to obtain these before processing the rest of the setup script or commands. This argument is needed if you are using distutils extensions as part of your build process; for example, extensions that process setup() arguments and turn them into EGG-INFO metadata files. (Note: projects listed in ``setup_requires`` will NOT be automatically installed on the system where the setup script is being run. They are simply downloaded to the ./.eggs directory if they're not locally available already. If you want them to be installed, as well as being available when the setup script is run, you should add them to ``install_requires`` **and** ``setup_requires``.) .. _keyword/dependency_links: ``dependency_links`` .. warning:: ``dependency_links`` is deprecated. It is not supported anymore by pip. A list of strings naming URLs to be searched when satisfying dependencies. These links will be used if needed to install packages specified by ``setup_requires`` or ``tests_require``. They will also be written into the egg's metadata for use during install by tools that support them. .. _keyword/namespace_packages: ``namespace_packages`` .. warning:: The ``namespace_packages`` implementation relies on ``pkg_resources``. However, ``pkg_resources`` has some undesirable behaviours, and Setuptools intends to obviate its usage in the future. Therefore, ``namespace_packages`` was deprecated in favor of native/implicit namespaces (:pep:`420`). Check :doc:`the Python Packaging User Guide ` for more information. A list of strings naming the project's "namespace packages". A namespace package is a package that may be split across multiple project distributions. For example, Zope 3's ``zope`` package is a namespace package, because subpackages like ``zope.interface`` and ``zope.publisher`` may be distributed separately. The egg runtime system can automatically merge such subpackages into a single parent package at runtime, as long as you declare them in each project that contains any subpackages of the namespace package, and as long as the namespace package's ``__init__.py`` does not contain any code other than a namespace declaration. See the section on :ref:`Namespace Packages` for more information. .. _keyword/test_suite: ``test_suite`` A string naming a ``unittest.TestCase`` subclass (or a package or module containing one or more of them, or a method of such a subclass), or naming a function that can be called with no arguments and returns a ``unittest.TestSuite``. If the named suite is a module, and the module has an ``additional_tests()`` function, it is called and the results are added to the tests to be run. If the named suite is a package, any submodules and subpackages are recursively added to the overall test suite. Specifying this argument enables use of the :ref:`test ` command to run the specified test suite, e.g. via ``setup.py test``. See the section on the :ref:`test ` command below for more details. .. warning:: .. deprecated:: 41.5.0 The test command will be removed in a future version of ``setuptools``, alongside any test configuration parameter. .. _keyword/tests_require: ``tests_require`` If your project's tests need one or more additional packages besides those needed to install it, you can use this option to specify them. It should be a string or list of strings specifying what other distributions need to be present for the package's tests to run. When you run the ``test`` command, ``setuptools`` will attempt to obtain these. Note that these required projects will *not* be installed on the system where the tests are run, but only downloaded to the project's setup directory if they're not already installed locally. .. warning:: .. deprecated:: 41.5.0 The test command will be removed in a future version of ``setuptools``, alongside any test configuration parameter. .. _test_loader: .. _keyword/test_loader: ``test_loader`` If you would like to use a different way of finding tests to run than what setuptools normally uses, you can specify a module name and class name in this argument. The named class must be instantiable with no arguments, and its instances must support the ``loadTestsFromNames()`` method as defined in the Python ``unittest`` module's ``TestLoader`` class. Setuptools will pass only one test "name" in the ``names`` argument: the value supplied for the ``test_suite`` argument. The loader you specify may interpret this string in any way it likes, as there are no restrictions on what may be contained in a ``test_suite`` string. The module name and class name must be separated by a ``:``. The default value of this argument is ``"setuptools.command.test:ScanningLoader"``. If you want to use the default ``unittest`` behavior, you can specify ``"unittest:TestLoader"`` as your ``test_loader`` argument instead. This will prevent automatic scanning of submodules and subpackages. The module and class you specify here may be contained in another package, as long as you use the ``tests_require`` option to ensure that the package containing the loader class is available when the ``test`` command is run. .. warning:: .. deprecated:: 41.5.0 The test command will be removed in a future version of ``setuptools``, alongside any test configuration parameter. .. _keyword/eager_resources: ``eager_resources`` A list of strings naming resources that should be extracted together, if any of them is needed, or if any C extensions included in the project are imported. This argument is only useful if the project will be installed as a zipfile, and there is a need to have all of the listed resources be extracted to the filesystem *as a unit*. Resources listed here should be '/'-separated paths, relative to the source root, so to list a resource ``foo.png`` in package ``bar.baz``, you would include the string ``bar/baz/foo.png`` in this argument. If you only need to obtain resources one at a time, or you don't have any C extensions that access other files in the project (such as data files or shared libraries), you probably do NOT need this argument and shouldn't mess with it. For more details on how this argument works, see the section below on :ref:`Automatic Resource Extraction`. .. _keyword/project_urls: ``project_urls`` An arbitrary map of URL names to hyperlinks, allowing more extensible documentation of where various resources can be found than the simple ``url`` and ``download_url`` options provide. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/roadmap.rst0000644000175100001730000000024114467657412016554 0ustar00runnerdocker======= Roadmap ======= Setuptools maintains a series of `milestones `_ to track a roadmap of large-scale goals. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/setuptools.rst0000644000175100001730000001523514467657412017363 0ustar00runnerdocker================================================== Building and Distributing Packages with Setuptools ================================================== ``Setuptools`` is a collection of enhancements to the Python ``distutils`` that allow developers to more easily build and distribute Python packages, especially ones that have dependencies on other packages. Packages built and distributed using ``setuptools`` look to the user like ordinary Python packages based on the ``distutils``. Feature Highlights: * Create `Python Eggs `_ - a single-file importable distribution format * Enhanced support for accessing data files hosted in zipped packages. * Automatically include all packages in your source tree, without listing them individually in setup.py * Automatically include all relevant files in your source distributions, without needing to create a |MANIFEST.in|_ file, and without having to force regeneration of the ``MANIFEST`` file when your source tree changes [#manifest]_. * Automatically generate wrapper scripts or Windows (console and GUI) .exe files for any number of "main" functions in your project. (Note: this is not a py2exe replacement; the .exe files rely on the local Python installation.) * Transparent Cython support, so that your setup.py can list ``.pyx`` files and still work even when the end-user doesn't have Cython installed (as long as you include the Cython-generated C in your source distribution) * Command aliases - create project-specific, per-user, or site-wide shortcut names for commonly used commands and options * Deploy your project in "development mode", such that it's available on ``sys.path``, yet can still be edited directly from its source checkout. * Easily extend the distutils with new commands or ``setup()`` arguments, and distribute/reuse your extensions for multiple projects, without copying code. * Create extensible applications and frameworks that automatically discover extensions, using simple "entry points" declared in a project's setup script. * Full support for PEP 420 via ``find_namespace_packages()``, which is also backwards compatible to the existing ``find_packages()`` for Python >= 3.3. ----------------- Developer's Guide ----------------- The developer's guide has been updated. See the :doc:`most recent version `. TRANSITIONAL NOTE ~~~~~~~~~~~~~~~~~ Setuptools automatically calls ``declare_namespace()`` for you at runtime, but future versions may *not*. This is because the automatic declaration feature has some negative side effects, such as needing to import all namespace packages during the initialization of the ``pkg_resources`` runtime, and also the need for ``pkg_resources`` to be explicitly imported before any namespace packages work at all. In some future releases, you'll be responsible for including your own declaration lines, and the automatic declaration feature will be dropped to get rid of the negative side effects. During the remainder of the current development cycle, therefore, setuptools will warn you about missing ``declare_namespace()`` calls in your ``__init__.py`` files, and you should correct these as soon as possible before the compatibility support is removed. Namespace packages without declaration lines will not work correctly once a user has upgraded to a later version, so it's important that you make this change now in order to avoid having your code break in the field. Our apologies for the inconvenience, and thank you for your patience. setup.cfg-only projects ======================= .. versionadded:: 40.9.0 If ``setup.py`` is missing from the project directory when a :pep:`517` build is invoked, ``setuptools`` emulates a dummy ``setup.py`` file containing only a ``setuptools.setup()`` call. .. note:: :pep:`517` doesn't support editable installs so this is currently incompatible with ``pip install -e .``. This means that you can have a Python project with all build configuration specified in ``setup.cfg``, without a ``setup.py`` file, if you **can rely on** your project always being built by a :pep:`517`/:pep:`518` compatible frontend. To use this feature: * Specify build requirements and :pep:`517` build backend in ``pyproject.toml``. For example: .. code-block:: toml [build-system] requires = [ "setuptools >= 40.9.0", ] build-backend = "setuptools.build_meta" * Use a :pep:`517` compatible build frontend, such as ``pip >= 19`` or ``build``. .. warning:: As :pep:`517` is new, support is not universal, and frontends that do support it may still have bugs. For compatibility, you may want to put a ``setup.py`` file containing only a ``setuptools.setup()`` invocation. Configuration API ================= Some automation tools may wish to access data from a configuration file. ``Setuptools`` exposes a ``read_configuration()`` function for parsing ``metadata`` and ``options`` sections into a dictionary. .. code-block:: python from setuptools.config import read_configuration conf_dict = read_configuration("/home/user/dev/package/setup.cfg") By default, ``read_configuration()`` will read only the file provided in the first argument. To include values from other configuration files which could be in various places, set the ``find_others`` keyword argument to ``True``. If you have only a configuration file but not the whole package, you can still try to get data out of it with the help of the ``ignore_option_errors`` keyword argument. When it is set to ``True``, all options with errors possibly produced by directives, such as ``attr:`` and others, will be silently ignored. As a consequence, the resulting dictionary will include no such options. Forum and Bug Tracker ===================== Please use `GitHub Discussions`_ for questions and discussion about setuptools, and the `setuptools bug tracker`_ ONLY for issues you have confirmed via the forum are actual bugs, and which you have reduced to a minimal set of steps to reproduce. .. _GitHub Discussions: https://github.com/pypa/setuptools/discussions .. _setuptools bug tracker: https://github.com/pypa/setuptools/ ---- .. [#manifest] The default behaviour for ``setuptools`` will work well for pure Python packages, or packages with simple C extensions (that don't require any special C header). See :ref:`Controlling files in the distribution` and :doc:`userguide/datafiles` for more information about complex scenarios, if you want to include other types of files. .. |MANIFEST.in| replace:: ``MANIFEST.in`` .. _MANIFEST.in: https://packaging.python.org/en/latest/guides/using-manifest-in/ ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.491548 setuptools-68.1.2/docs/userguide/0000755000175100001730000000000014467657443016402 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/datafiles.rst0000644000175100001730000004254614467657412021077 0ustar00runnerdocker==================== Data Files Support ==================== Old packaging installation methods in the Python ecosystem have traditionally allowed installation of "data files", which are placed in a platform-specific location. However, the most common use case for data files distributed with a package is for use *by* the package, usually by including the data files **inside the package directory**. Setuptools focuses on this most common type of data files and offers three ways of specifying which files should be included in your packages, as described in the following sections. include_package_data ==================== First, you can simply use the ``include_package_data`` keyword. For example, if the package tree looks like this:: project_root_directory ├── setup.py # and/or setup.cfg, pyproject.toml └── src └── mypkg ├── __init__.py ├── data1.rst ├── data2.rst ├── data1.txt └── data2.txt and you supply this configuration: .. tab:: setup.cfg .. code-block:: ini [options] # ... packages = find: package_dir = = src include_package_data = True [options.packages.find] where = src .. tab:: setup.py .. code-block:: python from setuptools import setup, find_packages setup( # ..., packages=find_packages(where="src"), package_dir={"": "src"}, include_package_data=True ) .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools] # ... # By default, include-package-data is true in pyproject.toml, so you do # NOT have to specify this line. include-package-data = true [tool.setuptools.packages.find] where = ["src"] then all the ``.txt`` and ``.rst`` files will be automatically installed with your package, provided: 1. These files are included via the |MANIFEST.in|_ file, like so:: include src/mypkg/*.txt include src/mypkg/*.rst 2. OR, they are being tracked by a revision control system such as Git, Mercurial or SVN, and you have configured an appropriate plugin such as :pypi:`setuptools-scm` or :pypi:`setuptools-svn`. (See the section below on :ref:`Adding Support for Revision Control Systems` for information on how to write such plugins.) package_data ============ By default, ``include_package_data`` considers **all** non ``.py`` files found inside the package directory (``src/mypkg`` in this case) as data files, and includes those that satisfy (at least) one of the above two conditions into the source distribution, and consequently in the installation of your package. If you want finer-grained control over what files are included, then you can also use the ``package_data`` keyword. For example, if the package tree looks like this:: project_root_directory ├── setup.py # and/or setup.cfg, pyproject.toml └── src └── mypkg ├── __init__.py ├── data1.rst ├── data2.rst ├── data1.txt └── data2.txt then you can use the following configuration to capture the ``.txt`` and ``.rst`` files as data files: .. tab:: setup.cfg .. code-block:: ini [options] # ... packages = find: package_dir = = src [options.packages.find] where = src [options.package_data] mypkg = *.txt *.rst .. tab:: setup.py .. code-block:: python from setuptools import setup, find_packages setup( # ..., packages=find_packages(where="src"), package_dir={"": "src"}, package_data={"mypkg": ["*.txt", "*.rst"]} ) .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools.packages.find] where = ["src"] [tool.setuptools.package-data] mypkg = ["*.txt", "*.rst"] The ``package_data`` argument is a dictionary that maps from package names to lists of glob patterns. Note that the data files specified using the ``package_data`` option neither require to be included within a |MANIFEST.in|_ file, nor require to be added by a revision control system plugin. .. note:: If your glob patterns use paths, you *must* use a forward slash (``/``) as the path separator, even if you are on Windows. Setuptools automatically converts slashes to appropriate platform-specific separators at build time. .. note:: Glob patterns do not automatically match dotfiles (directory or file names starting with a dot (``.``)). To include such files, you must explicitly start the pattern with a dot, e.g. ``.*`` to match ``.gitignore``. If you have multiple top-level packages and a common pattern of data files for all these packages, for example:: project_root_directory ├── setup.py # and/or setup.cfg, pyproject.toml └── src ├── mypkg1 │   ├── data1.rst │   ├── data1.txt │   └── __init__.py └── mypkg2 ├── data2.txt └── __init__.py Here, both packages ``mypkg1`` and ``mypkg2`` share a common pattern of having ``.txt`` data files. However, only ``mypkg1`` has ``.rst`` data files. In such a case, if you want to use the ``package_data`` option, the following configuration will work: .. tab:: setup.cfg .. code-block:: ini [options] packages = find: package_dir = = src [options.packages.find] where = src [options.package_data] * = *.txt mypkg1 = data1.rst .. tab:: setup.py .. code-block:: python from setuptools import setup, find_packages setup( # ..., packages=find_packages(where="src"), package_dir={"": "src"}, package_data={"": ["*.txt"], "mypkg1": ["data1.rst"]}, ) .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools.packages.find] where = ["src"] [tool.setuptools.package-data] "*" = ["*.txt"] mypkg1 = ["data1.rst"] Notice that if you list patterns in ``package_data`` under the empty string ``""`` in ``setup.py``, and the asterisk ``*`` in ``setup.cfg`` and ``pyproject.toml``, these patterns are used to find files in every package. For example, we use ``""`` or ``*`` to indicate that the ``.txt`` files from all packages should be captured as data files. Also note how we can continue to specify patterns for individual packages, i.e. we specify that ``data1.rst`` from ``mypkg1`` alone should be captured as well. .. note:: When building an ``sdist``, the datafiles are also drawn from the ``package_name.egg-info/SOURCES.txt`` file, so make sure that this is removed if the ``setup.py`` ``package_data`` list is updated before calling ``setup.py``. exclude_package_data ==================== Sometimes, the ``include_package_data`` or ``package_data`` options alone aren't sufficient to precisely define what files you want included. For example, consider a scenario where you have ``include_package_data=True``, and you are using a revision control system with an appropriate plugin. Sometimes developers add directory-specific marker files (such as ``.gitignore``, ``.gitkeep``, ``.gitattributes``, or ``.hgignore``), these files are probably being tracked by the revision control system, and therefore by default they will be included when the package is installed. Supposing you want to prevent these files from being included in the installation (they are not relevant to Python or the package), then you could use the ``exclude_package_data`` option: .. tab:: setup.cfg .. code-block:: ini [options] # ... packages = find: package_dir = = src include_package_data = True [options.packages.find] where = src [options.exclude_package_data] mypkg = .gitattributes .. tab:: setup.py .. code-block:: python from setuptools import setup, find_packages setup( # ..., packages=find_packages(where="src"), package_dir={"": "src"}, include_package_data=True, exclude_package_data={"mypkg": [".gitattributes"]}, ) .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools.packages.find] where = ["src"] [tool.setuptools.exclude-package-data] mypkg = [".gitattributes"] The ``exclude_package_data`` option is a dictionary mapping package names to lists of wildcard patterns, just like the ``package_data`` option. And, just as with that option, you can use the empty string key ``""`` in ``setup.py`` and the asterisk ``*`` in ``setup.cfg`` and ``pyproject.toml`` to match all top-level packages. Any files that match these patterns will be *excluded* from installation, even if they were listed in ``package_data`` or were included as a result of using ``include_package_data``. Subdirectory for Data Files =========================== A common pattern is where some (or all) of the data files are placed under a separate subdirectory. For example:: project_root_directory ├── setup.py # and/or setup.cfg, pyproject.toml └── src └── mypkg ├── data │   ├── data1.rst │   └── data2.rst ├── __init__.py ├── data1.txt └── data2.txt Here, the ``.rst`` files are placed under a ``data`` subdirectory inside ``mypkg``, while the ``.txt`` files are directly under ``mypkg``. In this case, the recommended approach is to treat ``data`` as a namespace package (refer :pep:`420`). With ``package_data``, the configuration might look like this: .. tab:: setup.cfg .. code-block:: ini [options] # ... packages = find_namespace: package_dir = = src [options.packages.find] where = src [options.package_data] mypkg = *.txt mypkg.data = *.rst .. tab:: setup.py .. code-block:: python from setuptools import setup, find_namespace_packages setup( # ..., packages=find_namespace_packages(where="src"), package_dir={"": "src"}, package_data={ "mypkg": ["*.txt"], "mypkg.data": ["*.rst"], } ) .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools.packages.find] # scanning for namespace packages is true by default in pyproject.toml, so # you do NOT need to include the following line. namespaces = true where = ["src"] [tool.setuptools.package-data] mypkg = ["*.txt"] "mypkg.data" = ["*.rst"] In other words, we allow Setuptools to scan for namespace packages in the ``src`` directory, which enables the ``data`` directory to be identified, and then, we separately specify data files for the root package ``mypkg``, and the namespace package ``data`` under the package ``mypkg``. With ``include_package_data`` the configuration is simpler: you simply need to enable scanning of namespace packages in the ``src`` directory and the rest is handled by Setuptools. .. tab:: setup.cfg .. code-block:: ini [options] packages = find_namespace: package_dir = = src include_package_data = True [options.packages.find] where = src .. tab:: setup.py .. code-block:: python from setuptools import setup, find_namespace_packages setup( # ... , packages=find_namespace_packages(where="src"), package_dir={"": "src"}, include_package_data=True, ) .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools] # ... # By default, include-package-data is true in pyproject.toml, so you do # NOT have to specify this line. include-package-data = true [tool.setuptools.packages.find] # scanning for namespace packages is true by default in pyproject.toml, so # you need NOT include the following line. namespaces = true where = ["src"] Summary ======= In summary, the three options allow you to: ``include_package_data`` Accept all data files and directories matched by |MANIFEST.in|_ or added by a :ref:`plugin `. ``package_data`` Specify additional patterns to match files that may or may not be matched by |MANIFEST.in|_ or added by a :ref:`plugin `. ``exclude_package_data`` Specify patterns for data files and directories that should *not* be included when a package is installed, even if they would otherwise have been included due to the use of the preceding options. .. note:: Due to the way the build process works, a data file that you include in your project and then stop including may be "orphaned" in your project's build directories, requiring you to run ``setup.py clean --all`` to fully remove them. This may also be important for your users and contributors if they track intermediate revisions of your project using Subversion; be sure to let them know when you make changes that remove files from inclusion so they can run ``setup.py clean --all``. .. _Accessing Data Files at Runtime: Accessing Data Files at Runtime =============================== Typically, existing programs manipulate a package's ``__file__`` attribute in order to find the location of data files. For example, if you have a structure like this:: project_root_directory ├── setup.py # and/or setup.cfg, pyproject.toml └── src └── mypkg ├── data │   └── data1.txt ├── __init__.py └── foo.py Then, in ``mypkg/foo.py``, you may try something like this in order to access ``mypkg/data/data1.txt``: .. code-block:: python import os data_path = os.path.join(os.path.dirname(__file__), 'data', 'data1.txt') with open(data_path, 'r') as data_file: ... However, this manipulation isn't compatible with :pep:`302`-based import hooks, including importing from zip files and Python Eggs. It is strongly recommended that, if you are using data files, you should use :mod:`importlib.resources` to access them. In this case, you would do something like this: .. code-block:: python from importlib.resources import files data_text = files('mypkg.data').joinpath('data1.txt').read_text() :mod:`importlib.resources` was added to Python 3.7. However, the API illustrated in this code (using ``files()``) was added only in Python 3.9, [#files_api]_ and support for accessing data files via namespace packages was added only in Python 3.10 [#namespace_support]_ (the ``data`` subdirectory is a namespace package under the root package ``mypkg``). Therefore, you may find this code to work only in Python 3.10 (and above). For other versions of Python, you are recommended to use the :pypi:`importlib-resources` backport which provides the latest version of this library. In this case, the only change that has to be made to the above code is to replace ``importlib.resources`` with ``importlib_resources``, i.e. .. code-block:: python from importlib_resources import files ... See :doc:`importlib-resources:using` for detailed instructions. .. tip:: Files inside the package directory should be *read-only* to avoid a series of common problems (e.g. when multiple users share a common Python installation, when the package is loaded from a zip file, or when multiple instances of a Python application run in parallel). If your Python package needs to write to a file for shared data or configuration, you can use standard platform/OS-specific system directories, such as ``~/.local/config/$appname`` or ``/usr/share/$appname/$version`` (Linux specific) [#system-dirs]_. A common approach is to add a read-only template file to the package directory that is then copied to the correct system directory if no pre-existing file is found. Non-Package Data Files ====================== Historically, ``setuptools`` by way of ``easy_install`` would encapsulate data files from the distribution into the egg (see `the old docs `_). As eggs are deprecated and pip-based installs fall back to the platform-specific location for installing data files, there is no supported facility to reliably retrieve these resources. Instead, the PyPA recommends that any data files you wish to be accessible at run time be included **inside the package**. ---- .. [#system-dirs] These locations can be discovered with the help of third-party libraries such as :pypi:`platformdirs`. .. [#files_api] Reference: https://importlib-resources.readthedocs.io/en/latest/using.html#migrating-from-legacy .. [#namespace_support] Reference: https://github.com/python/importlib_resources/pull/196#issuecomment-734520374 .. |MANIFEST.in| replace:: ``MANIFEST.in`` .. _MANIFEST.in: https://packaging.python.org/en/latest/guides/using-manifest-in/ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/declarative_config.rst0000644000175100001730000003140514467657412022743 0ustar00runnerdocker.. _declarative config: ------------------------------------------------ Configuring setuptools using ``setup.cfg`` files ------------------------------------------------ .. note:: New in 30.3.0 (8 Dec 2016). .. important:: If compatibility with legacy builds (i.e. those not using the :pep:`517` build API) is desired, a ``setup.py`` file containing a ``setup()`` function call is still required even if your configuration resides in ``setup.cfg``. ``Setuptools`` allows using configuration files (usually :file:`setup.cfg`) to define a package’s metadata and other options that are normally supplied to the ``setup()`` function (declarative config). This approach not only allows automation scenarios but also reduces boilerplate code in some cases. .. _example-setup-config: .. code-block:: ini [metadata] name = my_package version = attr: my_package.VERSION author = Josiah Carberry author_email = josiah_carberry@brown.edu description = My package description long_description = file: README.rst, CHANGELOG.rst, LICENSE.rst keywords = one, two license = BSD-3-Clause classifiers = Framework :: Django Programming Language :: Python :: 3 [options] zip_safe = False include_package_data = True packages = find: python_requires = >=3.7 install_requires = requests importlib-metadata; python_version<"3.8" [options.package_data] * = *.txt, *.rst hello = *.msg [options.entry_points] console_scripts = executable-name = my_package.module:function [options.extras_require] pdf = ReportLab>=1.2; RXP rest = docutils>=0.3; pack ==1.1, ==1.3 [options.packages.find] exclude = examples* tools* docs* my_package.tests* Metadata and options are set in the config sections of the same name. * Keys are the same as the :doc:`keyword arguments ` one provides to the ``setup()`` function. * Complex values can be written comma-separated or placed one per line in *dangling* config values. The following are equivalent: .. code-block:: ini [metadata] keywords = one, two [metadata] keywords = one two * In some cases, complex values can be provided in dedicated subsections for clarity. * Some keys allow ``file:``, ``attr:``, ``find:``, and ``find_namespace:`` directives in order to cover common usecases. * Unknown keys are ignored. Using a ``src/`` layout ======================= One commonly used configuration has all the Python source code in a subdirectory (often called the ``src/`` layout), like this:: ├── src │   └── mypackage │   ├── __init__.py │   └── mod1.py ├── setup.py └── setup.cfg You can set up your ``setup.cfg`` to automatically find all your packages in the subdirectory, using :ref:`package_dir `, like this: .. code-block:: ini # This example contains just the necessary options for a src-layout, set up # the rest of the file as described above. [options] package_dir= =src packages=find: [options.packages.find] where=src In this example, the value for the :ref:`package_dir ` configuration (i.e. ``=src``) is parsed as ``{"": "src"}``. The ``""`` key has a special meaning in this context, and indicates that all the packages are contained inside the given directory. Also note that the value for ``[options.packages.find] where`` matches the value associated with ``""`` in the ``package_dir`` dictionary. .. TODO: Add the following tip once the auto-discovery is no longer experimental: Starting in version 61, ``setuptools`` can automatically infer the configurations for both ``packages`` and ``package_dir`` for projects using a ``src/`` layout (as long as no value is specified for ``py_modules``). Please see :doc:`package discovery ` for more details. Specifying values ================= Some values are treated as simple strings, some allow more logic. Type names used below: * ``str`` - simple string * ``list-comma`` - dangling list or string of comma-separated values * ``list-semi`` - dangling list or string of semicolon-separated values * ``bool`` - ``True`` is 1, yes, true * ``dict`` - list-comma where each entry corresponds to a key/value pair, with keys separated from values by ``=``. If an entry starts with ``=``, the key is assumed to be an empty string (e.g. ``=src`` is parsed as ``{"": "src"}``). * ``section`` - values are read from a dedicated (sub)section Special directives: * ``attr:`` - Value is read from a module attribute. ``attr:`` supports callables and iterables; unsupported types are cast using ``str()``. In order to support the common case of a literal value assigned to a variable in a module containing (directly or indirectly) third-party imports, ``attr:`` first tries to read the value from the module by examining the module's AST. If that fails, ``attr:`` falls back to importing the module. * ``file:`` - Value is read from a list of files and then concatenated .. important:: The ``file:`` directive is sandboxed and won't reach anything outside the project directory (i.e. the directory containing ``setup.cfg``/``pyproject.toml``). .. note:: If you are using an old version of ``setuptools``, you might need to ensure that all files referenced by the ``file:`` directive are included in the ``sdist`` (you can do that via ``MANIFEST.in`` or using plugins such as ``setuptools-scm``, please have a look on :doc:`/userguide/miscellaneous` for more information). .. versionchanged:: 66.1.0 Newer versions of ``setuptools`` will automatically add these files to the ``sdist``. Metadata -------- .. attention:: The aliases given below are supported for compatibility reasons, but their use is not advised. ============================== ================= ================= =============== ========== Key Aliases Type Minimum Version Notes ============================== ================= ================= =============== ========== name str version attr:, file:, str 39.2.0 [#meta-1]_ url home-page str download_url download-url str project_urls dict 38.3.0 author str author_email author-email str maintainer str maintainer_email maintainer-email str classifiers classifier file:, list-comma license str license_files license_file list-comma 42.0.0 description summary file:, str long_description long-description file:, str long_description_content_type str 38.6.0 keywords list-comma platforms platform list-comma provides list-comma requires list-comma obsoletes list-comma ============================== ================= ================= =============== ========== **Notes**: .. [#meta-1] The ``version`` file attribute has only been supported since 39.2.0. A version loaded using the ``file:`` directive must comply with PEP 440. It is easy to accidentally put something other than a valid version string in such a file, so validation is stricter in this case. Options ------- ======================= =================================== =============== ==================== Key Type Minimum Version Notes ======================= =================================== =============== ==================== zip_safe bool setup_requires list-semi 36.7.0 install_requires file:, list-semi **BETA** [#opt-2]_, [#opt-6]_ extras_require file:, section **BETA** [#opt-2]_, [#opt-6]_ python_requires str 34.4.0 entry_points file:, section 51.0.0 scripts list-comma eager_resources list-comma dependency_links list-comma tests_require list-semi include_package_data bool packages find:, find_namespace:, list-comma [#opt-3]_ package_dir dict package_data section [#opt-1]_ exclude_package_data section namespace_packages list-comma [#opt-5]_ py_modules list-comma 34.4.0 data_files section 40.6.0 [#opt-4]_ ======================= =================================== =============== ==================== **Notes**: .. [#opt-1] In the ``package_data`` section, a key named with a single asterisk (``*``) refers to all packages, in lieu of the empty string used in ``setup.py``. .. [#opt-2] In ``install_requires`` and ``extras_require``, values are parsed as ``list-semi``. This implies that in order to include markers, each requirement **must** be *dangling* in a new line: .. code-block:: ini [options] install_requires = importlib-metadata; python_version<"3.8" [options.extras_require] all = importlib-metadata; python_version < "3.8" .. [#opt-3] The ``find:`` and ``find_namespace:`` directive can be further configured in a dedicated subsection ``options.packages.find``. This subsection accepts the same keys as the ``setuptools.find_packages`` and the ``setuptools.find_namespace_packages`` function: ``where``, ``include``, and ``exclude``. The ``find_namespace:`` directive is supported since Python >=3.3. .. [#opt-4] ``data_files`` is deprecated and should be avoided. Please check :doc:`/userguide/datafiles` for more information. .. [#opt-5] ``namespace_packages`` is deprecated in favour of native/implicit namespaces (:pep:`420`). Check :doc:`the Python Packaging User Guide ` for more information. .. [#opt-6] ``file:`` directives for reading requirements are supported since version 62.6. The format for the file resembles a ``requirements.txt`` file, however please keep in mind that all non-comment lines must conform with :pep:`508` (``pip``-specify syntaxes, e.g. ``-c/-r/-e`` flags, are not supported). Library developers should avoid tightly pinning their dependencies to a specific version (e.g. via a "locked" requirements file). Compatibility with other tools ============================== Historically, several tools explored declarative package configuration in parallel. And several of them chose to place the packaging configuration within the project's :file:`setup.cfg` file. One of the first was ``distutils2``, which development has stopped in 2013. Other include ``pbr`` which is still under active development or ``d2to1``, which was a plug-in that backports declarative configuration to ``distutils``, but has had no release since Oct. 2015. As a way to harmonize packaging tools, ``setuptools``, having held the position of *de facto* standard, has gradually integrated those features as part of its core features. Still this has lead to some confusion and feature incompatibilities: - some tools support features others don't; - some have similar features but the declarative syntax differs; The table below tries to summarize the differences. But, please, refer to each tool documentation for up-to-date information. =========================== ========== ========== ===== === feature setuptools distutils2 d2to1 pbr =========================== ========== ========== ===== === [metadata] description-file S Y Y Y [files] S Y Y Y entry_points Y Y Y S [backwards_compat] N Y Y Y =========================== ========== ========== ===== === Y: supported, N: unsupported, S: syntax differs (see :ref:`above example`). Also note that some features were only recently added to ``setuptools``. Please refer to the previous sections to find out when. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/dependency_management.rst0000644000175100001730000002651114467657412023447 0ustar00runnerdocker===================================== Dependencies Management in Setuptools ===================================== There are three types of dependency styles offered by setuptools: 1) build system requirement, 2) required dependency and 3) optional dependency. Each dependency, regardless of type, needs to be specified according to :pep:`508` and :pep:`440`. This allows adding version :pep:`range restrictions <440#version-specifiers>` and :ref:`environment markers `. .. _build-requires: Build system requirement ======================== After organizing all the scripts and files and getting ready for packaging, there needs to be a way to specify what programs and libraries are actually needed do the packaging (in our case, ``setuptools`` of course). This needs to be specified in your ``pyproject.toml`` file (if you have forgot what this is, go to :doc:`/userguide/quickstart` or :doc:`/build_meta`): .. code-block:: toml [build-system] requires = ["setuptools"] #... Please note that you should also include here any other ``setuptools`` plugin (e.g., :pypi:`setuptools-scm`, :pypi:`setuptools-golang`, :pypi:`setuptools-rust`) or build-time dependency (e.g., :pypi:`Cython`, :pypi:`cppy`, :pypi:`pybind11`). .. note:: In previous versions of ``setuptools``, this used to be accomplished with the ``setup_requires`` keyword but is now considered deprecated in favor of the :pep:`517` style described above. To peek into how this legacy keyword is used, consult our :doc:`guide on deprecated practice (WIP) `. .. _Declaring Dependencies: Declaring required dependency ============================= This is where a package declares its core dependencies, without which it won't be able to run. ``setuptools`` supports automatically downloading and installing these dependencies when the package is installed. Although there is more finesse to it, let's start with a simple example. .. tab:: pyproject.toml .. code-block:: toml [project] # ... dependencies = [ "docutils", "BazSpam == 1.1", ] # ... .. tab:: setup.cfg .. code-block:: ini [options] #... install_requires = docutils BazSpam ==1.1 .. tab:: setup.py .. code-block:: python setup( ..., install_requires=[ 'docutils', 'BazSpam ==1.1', ], ) When your project is installed (e.g., using :pypi:`pip`), all of the dependencies not already installed will be located (via `PyPI`_), downloaded, built (if necessary), and installed and 2) Any scripts in your project will be installed with wrappers that verify the availability of the specified dependencies at runtime. .. _environment-markers: Platform specific dependencies ------------------------------ Setuptools offers the capability to evaluate certain conditions before blindly installing everything listed in ``install_requires``. This is great for platform specific dependencies. For example, the ``enum`` package was added in Python 3.4, therefore, package that depends on it can elect to install it only when the Python version is older than 3.4. To accomplish this .. tab:: pyproject.toml .. code-block:: toml [project] # ... dependencies = [ "enum34; python_version<'3.4'", ] # ... .. tab:: setup.cfg .. code-block:: ini [options] #... install_requires = enum34;python_version<'3.4' .. tab:: setup.py .. code-block:: python setup( ..., install_requires=[ "enum34;python_version<'3.4'", ], ) Similarly, if you also wish to declare ``pywin32`` with a minimal version of 1.0 and only install it if the user is using a Windows operating system: .. tab:: pyproject.toml .. code-block:: toml [project] # ... dependencies = [ "enum34; python_version<'3.4'", "pywin32 >= 1.0; platform_system=='Windows'", ] # ... .. tab:: setup.cfg .. code-block:: ini [options] #... install_requires = enum34;python_version<'3.4' pywin32 >= 1.0;platform_system=='Windows' .. tab:: setup.py .. code-block:: python setup( ..., install_requires=[ "enum34;python_version<'3.4'", "pywin32 >= 1.0;platform_system=='Windows'", ], ) The environmental markers that may be used for testing platform types are detailed in :pep:`508`. .. seealso:: Alternatively, a :ref:`backend wrapper ` can be used for specific use cases where environment markers aren't sufficient. Direct URL dependencies ----------------------- .. attention:: `PyPI`_ and other standards-conformant package indices **do not** accept packages that declare dependencies using direct URLs. ``pip`` will accept them when installing packages from the local filesystem or from another URL, however. Dependencies that are not available on a package index but can be downloaded elsewhere in the form of a source repository or archive may be specified using a variant of :pep:`PEP 440's direct references <440#direct-references>`: .. tab:: pyproject.toml .. code-block:: toml [project] # ... dependencies = [ "Package-A @ git+https://example.net/package-a.git@main", "Package-B @ https://example.net/archives/package-b.whl", ] .. tab:: setup.cfg .. code-block:: ini [options] #... install_requires = Package-A @ git+https://example.net/package-a.git@main Package-B @ https://example.net/archives/package-b.whl .. tab:: setup.py .. code-block:: python setup( install_requires=[ "Package-A @ git+https://example.net/package-a.git@main", "Package-B @ https://example.net/archives/package-b.whl", ], ..., ) For source repository URLs, a list of supported protocols and VCS-specific features such as selecting certain branches or tags can be found in pip's documentation on `VCS support `_. Supported formats for archive URLs are sdists and wheels. Optional dependencies ===================== Setuptools allows you to declare dependencies that are not installed by default. This effectively means that you can create a "variant" of your package with a set of extra functionalities. For example, let's consider a ``Package-A`` that offers optional PDF support and requires two other dependencies for it to work: .. tab:: pyproject.toml .. code-block:: toml [project] name = "Package-A" # ... [project.optional-dependencies] PDF = ["ReportLab>=1.2", "RXP"] .. tab:: setup.cfg .. code-block:: ini [metadata] name = Package-A [options.extras_require] PDF = ReportLab>=1.2 RXP .. tab:: setup.py .. code-block:: python setup( name="Package-A", ..., extras_require={ "PDF": ["ReportLab>=1.2", "RXP"], }, ) .. sidebar:: .. tip:: It is also convenient to declare optional requirements for ancillary tasks such as running tests and or building docs. The name ``PDF`` is an arbitrary :pep:`identifier <685>` of such a list of dependencies, to which other components can refer and have them installed. A use case for this approach is that other package can use this "extra" for their own dependencies. For example, if ``Package-B`` needs ``Package-A`` with PDF support installed, it might declare the dependency like this: .. tab:: pyproject.toml .. code-block:: toml [project] name = "Package-B" # ... dependencies = [ "Package-A[PDF]" ] .. tab:: setup.cfg .. code-block:: ini [metadata] name = Package-B #... [options] #... install_requires = Package-A[PDF] .. tab:: setup.py .. code-block:: python setup( name="Package-B", install_requires=["Package-A[PDF]"], ..., ) This will cause ``ReportLab`` to be installed along with ``Package-A``, if ``Package-B`` is installed -- even if ``Package-A`` was already installed. In this way, a project can encapsulate groups of optional "downstream dependencies" under a feature name, so that packages that depend on it don't have to know what the downstream dependencies are. If a later version of ``Package-A`` builds in PDF support and no longer needs ``ReportLab``, or if it ends up needing other dependencies besides ``ReportLab`` in order to provide PDF support, ``Package-B``'s setup information does not need to change, but the right packages will still be installed if needed. .. tip:: Best practice: if a project ends up no longer needing any other packages to support a feature, it should keep an empty requirements list for that feature in its ``extras_require`` argument, so that packages depending on that feature don't break (due to an invalid feature name). .. warning:: Historically ``setuptools`` also used to support extra dependencies in console scripts, for example: .. tab:: setup.cfg .. code-block:: ini [metadata] name = Package-A #... [options] #... entry_points= [console_scripts] rst2pdf = project_a.tools.pdfgen [PDF] rst2html = project_a.tools.htmlgen .. tab:: setup.py .. code-block:: python setup( name="Package-A", ..., entry_points={ "console_scripts": [ "rst2pdf = project_a.tools.pdfgen [PDF]", "rst2html = project_a.tools.htmlgen", ], }, ) This syntax indicates that the entry point (in this case a console script) is only valid when the PDF extra is installed. It is up to the installer to determine how to handle the situation where PDF was not indicated (e.g., omit the console script, provide a warning when attempting to load the entry point, assume the extras are present and let the implementation fail later). **However**, ``pip`` and other tools might not support this use case for extra dependencies, therefore this practice is considered **deprecated**. See :doc:`PyPUG:specifications/entry-points`. Python requirement ================== In some cases, you might need to specify the minimum required python version. This can be configured as shown in the example below. .. tab:: pyproject.toml .. code-block:: toml [project] name = "Package-B" requires-python = ">=3.6" # ... .. tab:: setup.cfg .. code-block:: ini [metadata] name = Package-B #... [options] #... python_requires = >=3.6 .. tab:: setup.py .. code-block:: python setup( name="Package-B", python_requires=">=3.6", ..., ) .. _PyPI: https://pypi.org ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/development_mode.rst0000644000175100001730000002776414467657412022476 0ustar00runnerdockerDevelopment Mode (a.k.a. "Editable Installs") ============================================= When creating a Python project, developers usually want to implement and test changes iteratively, before cutting a release and preparing a distribution archive. In normal circumstances this can be quite cumbersome and require the developers to manipulate the ``PYTHONPATH`` environment variable or to continuously re-build and re-install the project. To facilitate iterative exploration and experimentation, setuptools allows users to instruct the Python interpreter and its import machinery to load the code under development directly from the project folder without having to copy the files to a different location in the disk. This means that changes in the Python source code can immediately take place without requiring a new installation. You can enter this "development mode" by performing an :doc:`editable installation ` inside of a :term:`virtual environment`, using :doc:`pip's ` ``-e/--editable`` flag, as shown below: .. code-block:: bash $ cd your-python-project $ python -m venv .venv # Activate your environment with: # `source .venv/bin/activate` on Unix/macOS # or `.venv\Scripts\activate` on Windows $ pip install --editable . # Now you have access to your package # as if it was installed in .venv $ python -c "import your_python_project" An "editable installation" works very similarly to a regular install with ``pip install .``, except that it only installs your package dependencies, metadata and wrappers for :ref:`console and GUI scripts `. Under the hood, setuptools will try to create a special :mod:`.pth file ` in the target directory (usually ``site-packages``) that extends the ``PYTHONPATH`` or install a custom :doc:`import hook `. When you're done with a given development task, you can simply uninstall your package (as you would normally do with ``pip uninstall ``). Please note that, by default an editable install will expose at least all the files that would be available in a regular installation. However, depending on the file and directory organization in your project, it might also expose as a side effect files that would not be normally available. This is allowed so you can iteratively create new Python modules. Please have a look on the following section if you are looking for a different behaviour. .. admonition:: Virtual Environments You can think about virtual environments as "isolated Python runtime deployments" that allow users to install different sets of libraries and tools without messing with the global behaviour of the system. They are a safe way of testing new projects and can be created easily with the :mod:`venv` module from the standard library. Please note however that depending on your operating system or distribution, ``venv`` might not come installed by default with Python. For those cases, you might need to use the OS package manager to install it. For example, in Debian/Ubuntu-based systems you can obtain it via: .. code-block:: bash sudo apt install python3-venv Alternatively, you can also try installing :pypi:`virtualenv`. More information is available on the Python Packaging User Guide on :doc:`PyPUG:guides/installing-using-pip-and-virtual-environments`. .. note:: .. versionchanged:: v64.0.0 Editable installation hooks implemented according to :pep:`660`. Support for :pep:`namespace packages <420>` is still **EXPERIMENTAL**. "Strict" editable installs -------------------------- When thinking about editable installations, users might have the following expectations: 1. It should allow developers to add new files (or split/rename existing ones) and have them automatically exposed. 2. It should behave as close as possible to a regular installation and help users to detect problems (e.g. new files not being included in the distribution). Unfortunately these expectations are in conflict with each other. To solve this problem ``setuptools`` allows developers to choose a more *"strict"* mode for the editable installation. This can be done by passing a special *configuration setting* via :pypi:`pip`, as indicated below: .. code-block:: bash pip install -e . --config-settings editable_mode=strict In this mode, new files **won't** be exposed and the editable installs will try to mimic as much as possible the behavior of a regular install. Under the hood, ``setuptools`` will create a tree of file links in an auxiliary directory (``$your_project_dir/build``) and add it to ``PYTHONPATH`` via a :mod:`.pth file `. (Please be careful to not delete this repository by mistake otherwise your files may stop being accessible). .. warning:: Strict editable installs require auxiliary files to be placed in a ``build/__editable__.*`` directory (relative to your project root). Please be careful to not remove this directory while testing your project, otherwise your editable installation may be compromised. You can remove the ``build/__editable__.*`` directory after uninstalling. .. note:: .. versionadded:: v64.0.0 Added new *strict* mode for editable installations. The exact details of how this mode is implemented may vary. Limitations ----------- - The *editable* term is used to refer only to Python modules inside the package directories. Non-Python files, external (data) files, executable script files, binary extensions, headers and metadata may be exposed as a *snapshot* of the version they were at the moment of the installation. - Adding new dependencies, entry-points or changing your project's metadata require a fresh "editable" re-installation. - Console scripts and GUI scripts **MUST** be specified via :doc:`entry-points ` to work properly. - *Strict* editable installs require the file system to support either :wiki:`symbolic ` or :wiki:`hard links `. This installation mode might also generate auxiliary files under the project directory. - There is *no guarantee* that the editable installation will be performed using a specific technique. Depending on each project, ``setuptools`` may select a different approach to ensure the package is importable at runtime. - There is *no guarantee* that files outside the top-level package directory will be accessible after an editable install. - There is *no guarantee* that attributes like ``__path__`` or ``__file__`` will correspond to the exact location of the original files (e.g., ``setuptools`` might employ file links to perform the editable installation). Users are encouraged to use tools like :mod:`importlib.resources` or :mod:`importlib.metadata` when trying to access package files directly. - Editable installations may not work with :doc:`namespaces created with pkgutil or pkg_resources `. Please use :pep:`420`-style implicit namespaces [#namespaces]_. - Support for :pep:`420`-style implicit namespace packages for projects structured using :ref:`flat-layout` is still **experimental**. If you experience problems, you can try converting your package structure to the :ref:`src-layout`. - File system entries in the current working directory whose names coincidentally match installed packages may take precedence in :doc:`Python's import system `. Users are encouraged to avoid such scenarios [#cwd]_. - Setuptools will try to give the right precedence to modules in an editable install. However this is not always an easy task. If you have a particular order in ``sys.path`` or some specific import precedence that needs to be respected, the editable installation as supported by Setuptools might not be able to fulfil this requirement, and therefore it might not be the right tool for your use case. .. attention:: Editable installs are **not a perfect replacement for regular installs** in a test environment. When in doubt, please test your projects as installed via a regular wheel. There are tools in the Python ecosystem, like :pypi:`tox` or :pypi:`nox`, that can help you with that (when used with appropriate configuration). Legacy Behavior --------------- If your project is not compatible with the new "editable installs" or you wish to replicate the legacy behavior, for the time being you can also perform the installation in the ``compat`` mode: .. code-block:: bash pip install -e . --config-settings editable_mode=compat This installation mode will try to emulate how ``python setup.py develop`` works (still within the context of :pep:`660`). .. warning:: The ``compat`` mode is *transitional* and will be removed in future versions of ``setuptools``, it exists only to help during the migration period. Also note that support for this mode is limited: it is safe to assume that the ``compat`` mode is offered "as is", and improvements are unlikely to be implemented. Users are encouraged to try out the new editable installation techniques and make the necessary adaptations. .. note:: Newer versions of ``pip`` no longer run the fallback command ``python setup.py develop`` when the ``pyproject.toml`` file is present. This means that setting the environment variable ``SETUPTOOLS_ENABLE_FEATURES="legacy-editable"`` will have no effect when installing a package with ``pip``. How editable installations work ------------------------------- *Advanced topic* There are many techniques that can be used to expose packages under development in such a way that they are available as if they were installed. Depending on the project file structure and the selected mode, ``setuptools`` will choose one of these approaches for the editable installation [#criteria]_. A non-exhaustive list of implementation mechanisms is presented below. More information is available on the text of :pep:`PEP 660 <660#what-to-put-in-the-wheel>`. - A static ``.pth`` file [#static_pth]_ can be added to one of the directories listed in :func:`site.getsitepackages` or :func:`site.getusersitepackages` to extend :obj:`sys.path`. - A directory containing a *farm of file links* that mimic the project structure and point to the original files can be employed. This directory can then be added to :obj:`sys.path` using a static ``.pth`` file. - A dynamic ``.pth`` file [#dynamic_pth]_ can also be used to install an "import :term:`finder`" (:obj:`~importlib.abc.MetaPathFinder` or :obj:`~importlib.abc.PathEntryFinder`) that will hook into Python's :doc:`import system ` machinery. .. attention:: ``Setuptools`` offers **no guarantee** of which technique will be used to perform an editable installation. This will vary from project to project and may change depending on the specific version of ``setuptools`` being used. ---- .. rubric:: Notes .. [#namespaces] You *may* be able to use *strict* editable installations with namespace packages created with ``pkgutil`` or ``pkg_namespaces``, however this is not officially supported. .. [#cwd] Techniques like the :ref:`src-layout` or tooling-specific options like `tox's changedir `_ can be used to prevent such kinds of situations (checkout `this blog post `_ for more insights). .. [#criteria] ``setuptools`` strives to find a balance between allowing the user to see the effects of project files being edited while still trying to keep the editable installation as similar as possible to a regular installation. .. [#static_pth] i.e., a ``.pth`` file where each line correspond to a path that should be added to :obj:`sys.path`. See :mod:`Site-specific configuration hook `. .. [#dynamic_pth] i.e., a ``.pth`` file that starts where each line starts with an ``import`` statement and executes arbitrary Python code. See :mod:`Site-specific configuration hook `. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/distribution.rst0000644000175100001730000002411214467657412021647 0ustar00runnerdocker.. _Specifying Your Project's Version: Specifying Your Project's Version ================================= Setuptools can work well with most versioning schemes. Over the years, setuptools has tried to closely follow the :pep:`440` scheme, but it also supports legacy versions. There are, however, a few special things to watch out for, in order to ensure that setuptools and other tools can always tell what version of your package is newer than another version. Knowing these things will also help you correctly specify what versions of other projects your project depends on. A version consists of an alternating series of release numbers and `pre-release `_ or `post-release `_ tags. A release number is a series of digits punctuated by dots, such as ``2.4`` or ``0.5``. Each series of digits is treated numerically, so releases ``2.1`` and ``2.1.0`` are different ways to spell the same release number, denoting the first subrelease of release 2. But ``2.10`` is the *tenth* subrelease of release 2, and so is a different and newer release from ``2.1`` or ``2.1.0``. Leading zeros within a series of digits are also ignored, so ``2.01`` is the same as ``2.1``, and different from ``2.0.1``. Following a release number, you can have either a pre-release or post-release tag. Pre-release tags make a version be considered *older* than the version they are appended to. So, revision ``2.4`` is *newer* than release candidate ``2.4rc1``, which in turn is newer than beta release ``2.4b1`` or alpha release ``2.4a1``. Postrelease tags make a version be considered *newer* than the version they are appended to. So, revisions like ``2.4.post1`` are newer than ``2.4``, but *older* than ``2.4.1`` (which has a higher release number). In the case of legacy versions (for example, ``2.4pl1``), they are considered older than non-legacy versions. Taking that in count, a revision ``2.4pl1`` is *older* than ``2.4``. Note that ``2.4pl1`` is not :pep:`440`-compliant. A pre-release tag is a series of letters that are alphabetically before "final". Some examples of prerelease tags would include ``alpha``, ``beta``, ``a``, ``c``, ``dev``, and so on. You do not have to place a dot or dash before the prerelease tag if it's immediately after a number, but it's okay to do so if you prefer. Thus, ``2.4c1`` and ``2.4.c1`` and ``2.4-c1`` all represent release candidate 1 of version ``2.4``, and are treated as identical by setuptools. Note that only ``a``, ``b``, and ``rc`` are :pep:`440`-compliant pre-release tags. In addition, there are three special prerelease tags that are treated as if they were ``rc``: ``c``, ``pre``, and ``preview``. So, version ``2.4c1``, ``2.4pre1`` and ``2.4preview1`` are all the exact same version as ``2.4rc1``, and are treated as identical by setuptools. A post-release tag is the string ``.post``, followed by a non-negative integer value. Post-release tags are generally used to separate patch numbers, port numbers, build numbers, revision numbers, or date stamps from the release number. For example, the version ``2.4.post1263`` might denote Subversion revision 1263 of a post-release patch of version ``2.4``. Or you might use ``2.4.post20051127`` to denote a date-stamped post-release. Legacy post-release tags could be either a series of letters that are alphabetically greater than or equal to "final", or a dash (``-``) - for example ``2.4-r1263`` or ``2.4-20051127``. Notice that after each legacy pre or post-release tag, you are free to place another release number, followed again by more pre- or post-release tags. For example, ``0.6a9.dev41475`` could denote Subversion revision 41475 of the in-development version of the ninth alpha of release 0.6. Notice that ``dev`` is a pre-release tag, so this version is a *lower* version number than ``0.6a9``, which would be the actual ninth alpha of release 0.6. But the ``41475`` is a post-release tag, so this version is *newer* than ``0.6a9.dev``. For the most part, setuptools' interpretation of version numbers is intuitive, but here are a few tips that will keep you out of trouble in the corner cases: * Don't stick adjoining pre-release tags together without a dot or number between them. Version ``1.9adev`` is the ``adev`` prerelease of ``1.9``, *not* a development pre-release of ``1.9a``. Use ``.dev`` instead, as in ``1.9a.dev``, or separate the prerelease tags with a number, as in ``1.9a0dev``. ``1.9a.dev``, ``1.9a0dev``, and even ``1.9a0.dev0`` are identical versions from setuptools' point of view, so you can use whatever scheme you prefer. Of these examples, only ``1.9a0.dev0`` is :pep:`440`-compliant. * If you want to be certain that your chosen numbering scheme works the way you think it will, you can use the ``pkg_resources.parse_version()`` function to compare different version numbers:: >>> from pkg_resources import parse_version >>> parse_version("1.9.a.dev") == parse_version("1.9a0dev") True >>> parse_version("2.1-rc2") < parse_version("2.1") True >>> parse_version("0.6a9dev-r41475") < parse_version("0.6a9") True Once you've decided on a version numbering scheme for your project, you can have setuptools automatically tag your in-development releases with various pre- or post-release tags. See the following section for more details. Tagging and "Daily Build" or "Snapshot" Releases ------------------------------------------------ .. warning:: Please note that running ``python setup.py ...`` directly is no longer considered a good practice and that in the future the commands ``egg_info`` and ``rotate`` will be deprecated. As a result, the instructions and information presented in this section should be considered **transitional** while setuptools don't provide a mechanism for tagging releases. Meanwhile, if you can also consider using :pypi:`setuptools-scm` to achieve similar objectives. When a set of related projects are under development, it may be important to track finer-grained version increments than you would normally use for e.g. "stable" releases. While stable releases might be measured in dotted numbers with alpha/beta/etc. status codes, development versions of a project often need to be tracked by revision or build number or even build date. This is especially true when projects in development need to refer to one another, and therefore may literally need an up-to-the-minute version of something! To support these scenarios, ``setuptools`` allows you to "tag" your source and egg distributions by adding one or more of the following to the project's "official" version identifier: * A manually-specified pre-release tag, such as "build" or "dev", or a manually-specified post-release tag, such as a build or revision number (``--tag-build=STRING, -bSTRING``) * An 8-character representation of the build date (``--tag-date, -d``), as a postrelease tag You can add these tags by adding ``egg_info`` and the desired options to the command line ahead of the ``sdist`` or ``bdist`` commands that you want to generate a daily build or snapshot for. See the section below on the :ref:`egg_info ` command for more details. (Also, before you release your project, be sure to see the section on :ref:`Specifying Your Project's Version` for more information about how pre- and post-release tags affect how version numbers are interpreted. This is important in order to make sure that dependency processing tools will know which versions of your project are newer than others). Finally, if you are creating builds frequently, and either building them in a downloadable location or are copying them to a distribution server, you should probably also check out the :ref:`rotate ` command, which lets you automatically delete all but the N most-recently-modified distributions matching a glob pattern. So, you can use a command line like:: setup.py egg_info -rbDEV bdist_egg rotate -m.egg -k3 to build an egg whose version info includes "DEV-rNNNN" (where NNNN is the most recent Subversion revision that affected the source tree), and then delete any egg files from the distribution directory except for the three that were built most recently. If you have to manage automated builds for multiple packages, each with different tagging and rotation policies, you may also want to check out the :ref:`alias ` command, which would let each package define an alias like ``daily`` that would perform the necessary tag, build, and rotate commands. Then, a simpler script or cron job could just run ``setup.py daily`` in each project directory. (And, you could also define sitewide or per-user default versions of the ``daily`` alias, so that projects that didn't define their own would use the appropriate defaults.) Making "Official" (Non-Snapshot) Releases ----------------------------------------- When you make an official release, creating source or binary distributions, you will need to override the tag settings from ``setup.cfg``, so that you don't end up registering versions like ``foobar-0.7a1.dev-r34832``. This is easy to do if you are developing on the trunk and using tags or branches for your releases - just make the change to ``setup.cfg`` after branching or tagging the release, so the trunk will still produce development snapshots. Alternately, if you are not branching for releases, you can override the default version options on the command line, using something like:: setup.py egg_info -Db "" sdist bdist_egg The first part of this command (``egg_info -Db ""``) will override the configured tag information, before creating source and binary eggs. Thus, these commands will use the plain version from your ``setup.py``, without adding the build designation string. Of course, if you will be doing this a lot, you may wish to create a personal alias for this operation, e.g.:: setup.py alias -u release egg_info -Db "" You can then use it like this:: setup.py release sdist bdist_egg Or of course you can create more elaborate aliases that do all of the above. See the sections below on the :ref:`egg_info ` and :ref:`alias ` commands for more ideas. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/entry_point.rst0000644000175100001730000004367314467657412021517 0ustar00runnerdocker.. _`entry_points`: ============ Entry Points ============ Entry points are a type of metadata that can be exposed by packages on installation. They are a very useful feature of the Python ecosystem, and come specially handy in two scenarios: 1. The package would like to provide commands to be run at the terminal. This functionality is known as *console* scripts. The command may also open up a GUI, in which case it is known as a *GUI* script. An example of a console script is the one provided by the :pypi:`pip` package, which allows you to run commands like ``pip install`` in the terminal. 2. A package would like to enable customization of its functionalities via *plugins*. For example, the test framework :pypi:`pytest` allows customization via the ``pytest11`` entry point, and the syntax highlighting tool :pypi:`pygments` allows specifying additional styles using the entry point ``pygments.styles``. .. _console-scripts: Console Scripts =============== Let us start with console scripts. First consider an example without entry points. Imagine a package defined thus:: project_root_directory ├── pyproject.toml # and/or setup.cfg, setup.py └── src └── timmins ├── __init__.py └── ... with ``__init__.py`` as: .. code-block:: python def hello_world(): print("Hello world") Now, suppose that we would like to provide some way of executing the function ``hello_world()`` from the command-line. One way to do this is to create a file ``src/timmins/__main__.py`` providing a hook as follows: .. code-block:: python from . import hello_world if __name__ == '__main__': hello_world() Then, after installing the package ``timmins``, we may invoke the ``hello_world()`` function as follows, through the `runpy `_ module: .. code-block:: bash $ python -m timmins Hello world Instead of this approach using ``__main__.py``, you can also create a user-friendly CLI executable that can be called directly without ``python -m``. In the above example, to create a command ``hello-world`` that invokes ``timmins.hello_world``, add a console script entry point to your configuration: .. tab:: pyproject.toml .. code-block:: toml [project.scripts] hello-world = "timmins:hello_world" .. tab:: setup.cfg .. code-block:: ini [options.entry_points] console_scripts = hello-world = timmins:hello_world .. tab:: setup.py .. code-block:: python from setuptools import setup setup( # ..., entry_points={ 'console_scripts': [ 'hello-world = timmins:hello_world', ] } ) After installing the package, a user may invoke that function by simply calling ``hello-world`` on the command line: .. code-block:: bash $ hello-world Hello world Note that any function used as a console script, i.e. ``hello_world()`` in this example, should not accept any arguments. If your function requires any input from the user, you can use regular command-line argument parsing utilities like :mod:`argparse` within the body of the function to parse user input given via :obj:`sys.argv`. You may have noticed that we have used a special syntax to specify the function that must be invoked by the console script, i.e. we have written ``timmins:hello_world`` with a colon ``:`` separating the package name and the function name. The full specification of this syntax is discussed in the `last section <#entry-points-syntax>`_ of this document, and this can be used to specify a function located anywhere in your package, not just in ``__init__.py``. GUI Scripts =========== In addition to ``console_scripts``, Setuptools supports ``gui_scripts``, which will launch a GUI application without running in a terminal window. For example, if we have a project with the same directory structure as before, with an ``__init__.py`` file containing the following: .. code-block:: python import PySimpleGUI as sg def hello_world(): sg.Window(title="Hello world", layout=[[]], margins=(100, 50)).read() Then, we can add a GUI script entry point: .. tab:: pyproject.toml .. code-block:: toml [project.gui-scripts] hello-world = "timmins:hello_world" .. tab:: setup.cfg .. code-block:: ini [options.entry_points] gui_scripts = hello-world = timmins:hello_world .. tab:: setup.py .. code-block:: python from setuptools import setup setup( # ..., entry_points={ 'gui_scripts': [ 'hello-world = timmins:hello_world', ] } ) .. note:: To be able to import ``PySimpleGUI``, you need to add ``pysimplegui`` to your package dependencies. See :doc:`/userguide/dependency_management` for more information. Now, running: .. code-block:: bash $ hello-world will open a small application window with the title 'Hello world'. Note that just as with console scripts, any function used as a GUI script should not accept any arguments, and any user input can be parsed within the body of the function. GUI scripts also use the same syntax (discussed in the `last section <#entry-points-syntax>`_) for specifying the function to be invoked. .. note:: The difference between ``console_scripts`` and ``gui_scripts`` only affects Windows systems. [#use_for_scripts]_ ``console_scripts`` are wrapped in a console executable, so they are attached to a console and can use ``sys.stdin``, ``sys.stdout`` and ``sys.stderr`` for input and output. ``gui_scripts`` are wrapped in a GUI executable, so they can be started without a console, but cannot use standard streams unless application code redirects them. Other platforms do not have the same distinction. .. note:: Console and GUI scripts work because behind the scenes, installers like :pypi:`pip` create wrapper scripts around the function(s) being invoked. For example, the ``hello-world`` entry point in the above two examples would create a command ``hello-world`` launching a script like this: [#use_for_scripts]_ .. code-block:: python import sys from timmins import hello_world sys.exit(hello_world()) .. _dynamic discovery of services and plugins: Advertising Behavior ==================== Console/GUI scripts are one use of the more general concept of entry points. Entry points more generally allow a packager to advertise behavior for discovery by other libraries and applications. This feature enables "plug-in"-like functionality, where one library solicits entry points and any number of other libraries provide those entry points. A good example of this plug-in behavior can be seen in `pytest plugins `_, where pytest is a test framework that allows other libraries to extend or modify its functionality through the ``pytest11`` entry point. The console/GUI scripts work similarly, where libraries advertise their commands and tools like ``pip`` create wrapper scripts that invoke those commands. Entry Points for Plugins ======================== Let us consider a simple example to understand how we can implement entry points corresponding to plugins. Say we have a package ``timmins`` with the following directory structure:: timmins ├── pyproject.toml # and/or setup.cfg, setup.py └── src └── timmins └── __init__.py and in ``src/timmins/__init__.py`` we have the following code: .. code-block:: python def hello_world(): print('Hello world') Basically, we have defined a ``hello_world()`` function which will print the text 'Hello world'. Now, let us say we want to print the text 'Hello world' in different ways. The current function just prints the text as it is - let us say we want another style in which the text is enclosed within exclamation marks:: !!! Hello world !!! Let us see how this can be done using plugins. First, let us separate the style of printing the text from the text itself. In other words, we can change the code in ``src/timmins/__init__.py`` to something like this: .. code-block:: python def display(text): print(text) def hello_world(): display('Hello world') Here, the ``display()`` function controls the style of printing the text, and the ``hello_world()`` function calls the ``display()`` function to print the text 'Hello world`. Right now the ``display()`` function just prints the text as it is. In order to be able to customize it, we can do the following. Let us introduce a new *group* of entry points named ``timmins.display``, and expect plugin packages implementing this entry point to supply a ``display()``-like function. Next, to be able to automatically discover plugin packages that implement this entry point, we can use the :mod:`importlib.metadata` module, as follows: .. code-block:: python from importlib.metadata import entry_points display_eps = entry_points(group='timmins.display') .. note:: Each ``importlib.metadata.EntryPoint`` object is an object containing a ``name``, a ``group``, and a ``value``. For example, after setting up the plugin package as described below, ``display_eps`` in the above code will look like this: [#package_metadata]_ .. code-block:: python ( EntryPoint(name='excl', value='timmins_plugin_fancy:excl_display', group='timmins.display'), ..., ) ``display_eps`` will now be a list of ``EntryPoint`` objects, each referring to ``display()``-like functions defined by one or more installed plugin packages. Then, to import a specific ``display()``-like function - let us choose the one corresponding to the first discovered entry point - we can use the ``load()`` method as follows: .. code-block:: python display = display_eps[0].load() Finally, a sensible behaviour would be that if we cannot find any plugin packages customizing the ``display()`` function, we should fall back to our default implementation which prints the text as it is. With this behaviour included, the code in ``src/timmins/__init__.py`` finally becomes: .. code-block:: python from importlib.metadata import entry_points display_eps = entry_points(group='timmins.display') try: display = display_eps[0].load() except IndexError: def display(text): print(text) def hello_world(): display('Hello world') That finishes the setup on ``timmins``'s side. Next, we need to implement a plugin which implements the entry point ``timmins.display``. Let us name this plugin ``timmins-plugin-fancy``, and set it up with the following directory structure:: timmins-plugin-fancy ├── pyproject.toml # and/or setup.cfg, setup.py └── src └── timmins_plugin_fancy └── __init__.py And then, inside ``src/timmins_plugin_fancy/__init__.py``, we can put a function named ``excl_display()`` that prints the given text surrounded by exclamation marks: .. code-block:: python def excl_display(text): print('!!!', text, '!!!') This is the ``display()``-like function that we are looking to supply to the ``timmins`` package. We can do that by adding the following in the configuration of ``timmins-plugin-fancy``: .. tab:: pyproject.toml .. code-block:: toml # Note the quotes around timmins.display in order to escape the dot . [project.entry-points."timmins.display"] excl = "timmins_plugin_fancy:excl_display" .. tab:: setup.cfg .. code-block:: ini [options.entry_points] timmins.display = excl = timmins_plugin_fancy:excl_display .. tab:: setup.py .. code-block:: python from setuptools import setup setup( # ..., entry_points = { 'timmins.display': [ 'excl = timmins_plugin_fancy:excl_display' ] } ) Basically, this configuration states that we are a supplying an entry point under the group ``timmins.display``. The entry point is named ``excl`` and it refers to the function ``excl_display`` defined by the package ``timmins-plugin-fancy``. Now, if we install both ``timmins`` and ``timmins-plugin-fancy``, we should get the following: .. code-block:: pycon >>> from timmins import hello_world >>> hello_world() !!! Hello world !!! whereas if we only install ``timmins`` and not ``timmins-plugin-fancy``, we should get the following: .. code-block:: pycon >>> from timmins import hello_world >>> hello_world() Hello world Therefore, our plugin works. Our plugin could have also defined multiple entry points under the group ``timmins.display``. For example, in ``src/timmins_plugin_fancy/__init__.py`` we could have two ``display()``-like functions, as follows: .. code-block:: python def excl_display(text): print('!!!', text, '!!!') def lined_display(text): print(''.join(['-' for _ in text])) print(text) print(''.join(['-' for _ in text])) The configuration of ``timmins-plugin-fancy`` would then change to: .. tab:: pyproject.toml .. code-block:: toml [project.entry-points."timmins.display"] excl = "timmins_plugin_fancy:excl_display" lined = "timmins_plugin_fancy:lined_display" .. tab:: setup.cfg .. code-block:: ini [options.entry_points] timmins.display = excl = timmins_plugin_fancy:excl_display lined = timmins_plugin_fancy:lined_display .. tab:: setup.py .. code-block:: python from setuptools import setup setup( # ..., entry_points = { 'timmins.display': [ 'excl = timmins_plugin_fancy:excl_display', 'lined = timmins_plugin_fancy:lined_display', ] } ) On the ``timmins`` side, we can also use a different strategy of loading entry points. For example, we can search for a specific display style: .. code-block:: python display_eps = entry_points(group='timmins.display') try: display = display_eps['lined'].load() except KeyError: # if the 'lined' display is not available, use something else ... Or we can also load all plugins under the given group. Though this might not be of much use in our current example, there are several scenarios in which this is useful: .. code-block:: python display_eps = entry_points(group='timmins.display') for ep in display_eps: display = ep.load() # do something with display ... Another point is that in this particular example, we have used plugins to customize the behaviour of a function (``display()``). In general, we can use entry points to enable plugins to not only customize the behaviour of functions, but also of entire classes and modules. This is unlike the case of console/GUI scripts, where entry points can only refer to functions. The syntax used for specifying the entry points remains the same as for console/GUI scripts, and is discussed in the `last section <#entry-points-syntax>`_. .. tip:: The recommended approach for loading and importing entry points is the :mod:`importlib.metadata` module, which is a part of the standard library since Python 3.8. For older versions of Python, its backport :pypi:`importlib_metadata` should be used. While using the backport, the only change that has to be made is to replace ``importlib.metadata`` with ``importlib_metadata``, i.e. .. code-block:: python from importlib_metadata import entry_points ... In summary, entry points allow a package to open its functionalities for customization via plugins. The package soliciting the entry points need not have any dependency or prior knowledge about the plugins implementing the entry points, and downstream users are able to compose functionality by pulling together plugins implementing the entry points. Entry Points Syntax =================== The syntax for entry points is specified as follows:: = [:[.[.]*]] Here, the square brackets ``[]`` denote optionality and the asterisk ``*`` denotes repetition. ``name`` is the name of the script/entry point you want to create, the left hand side of ``:`` is the package or module that contains the object you want to invoke (think about it as something you would write in an import statement), and the right hand side is the object you want to invoke (e.g. a function). To make this syntax more clear, consider the following examples: Package or module If you supply:: = as the entry point, where ```` can contain ``.`` in the case of sub-modules or sub-packages, then, tools in the Python ecosystem will roughly interpret this value as: .. code-block:: python import parsed_value = Module-level object If you supply:: = : where ```` does not contain any ``.``, this will be roughly interpreted as: .. code-block:: python from import parsed_value = Nested object If you supply:: = :.. this will be roughly interpreted as: .. code-block:: python from import parsed_value = .. In the case of console/GUI scripts, this syntax can be used to specify a function, while in the general case of entry points as used for plugins, it can be used to specify a function, class or module. ---- .. [#use_for_scripts] Reference: https://packaging.python.org/en/latest/specifications/entry-points/#use-for-scripts .. [#package_metadata] Reference: https://packaging.python.org/en/latest/guides/creating-and-discovering-plugins/#using-package-metadata ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/ext_modules.rst0000644000175100001730000001605514467657412021467 0ustar00runnerdocker========================== Building Extension Modules ========================== Setuptools can build C/C++ extension modules. The keyword argument ``ext_modules`` of ``setup()`` should be a list of instances of the :class:`setuptools.Extension` class. For example, let's consider a simple project with only one extension module:: ├── pyproject.toml └── foo.c and all project metadata configuration in the ``pyproject.toml`` file: .. code-block:: toml # pyproject.toml [build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" [project] name = "mylib-foo" # as it would appear on PyPI version = "0.42" To instruct setuptools to compile the ``foo.c`` file into the extension module ``mylib.foo``, we need to add a ``setup.py`` file similar to the following: .. code-block:: python from setuptools import Extension, setup setup( ext_modules=[ Extension( name="mylib.foo", # as it would be imported # may include packages/namespaces separated by `.` sources=["foo.c"], # all sources are compiled into a single binary file ), ] ) .. seealso:: You can find more information on the `Python docs about C/C++ extensions`_. Alternatively, you might also be interested in learning about `Cython`_. If you plan to distribute a package that uses extensions across multiple platforms, :pypi:`cibuildwheel` can also be helpful. .. important:: All files used to compile your extension need to be available on the system when building the package, so please make sure to include some documentation on how developers interested in building your package from source can obtain operating system level dependencies (e.g. compilers and external binary libraries/artifacts). You will also need to make sure that all auxiliary files that are contained inside your :term:`project` (e.g. C headers authored by you or your team) are configured to be included in your :term:`sdist `. Please have a look on our section on :ref:`Controlling files in the distribution`. Compiler and linker options =========================== The command ``build_ext`` builds C/C++ extension modules. It creates a command line for running the compiler and linker by combining compiler and linker options from various sources: .. Reference: `test_customize_compiler` in distutils/tests/test_sysconfig.py * the ``sysconfig`` variables ``CC``, ``CXX``, ``CCSHARED``, ``LDSHARED``, and ``CFLAGS``, * the environment variables ``CC``, ``CPP``, ``CXX``, ``LDSHARED`` and ``CFLAGS``, ``CPPFLAGS``, ``LDFLAGS``, * the ``Extension`` attributes ``include_dirs``, ``library_dirs``, ``extra_compile_args``, ``extra_link_args``, ``runtime_library_dirs``. .. Ignoring AR, ARFLAGS, RANLIB here because they are used by the (obsolete?) build_clib, not build_ext. Specifically, if the environment variables ``CC``, ``CPP``, ``CXX``, and ``LDSHARED`` are set, they will be used instead of the ``sysconfig`` variables of the same names. The compiler options appear in the command line in the following order: .. Reference: "compiler_so" and distutils.ccompiler.gen_preprocess_options, CCompiler.compile, UnixCCompiler._compile * first, the options provided by the ``sysconfig`` variable ``CFLAGS``, * then, the options provided by the environment variables ``CFLAGS`` and ``CPPFLAGS``, * then, the options provided by the ``sysconfig`` variable ``CCSHARED``, * then, a ``-I`` option for each element of ``Extension.include_dirs``, * finally, the options provided by ``Extension.extra_compile_args``. The linker options appear in the command line in the following order: .. Reference: "linker_so" and CCompiler.link * first, the options provided by environment variables and ``sysconfig`` variables, * then, a ``-L`` option for each element of ``Extension.library_dirs``, * then, a linker-specific option like ``-Wl,-rpath`` for each element of ``Extension.runtime_library_dirs``, * finally, the options provided by ``Extension.extra_link_args``. The resulting command line is then processed by the compiler and linker. According to the GCC manual sections on `directory options`_ and `environment variables`_, the C/C++ compiler searches for files named in ``#include `` directives in the following order: * first, in directories given by ``-I`` options (in left-to-right order), * then, in directories given by the environment variable ``CPATH`` (in left-to-right order), * then, in directories given by ``-isystem`` options (in left-to-right order), * then, in directories given by the environment variable ``C_INCLUDE_PATH`` (for C) and ``CPLUS_INCLUDE_PATH`` (for C++), * then, in standard system directories, * finally, in directories given by ``-idirafter`` options (in left-to-right order). The linker searches for libraries in the following order: * first, in directories given by ``-L`` options (in left-to-right order), * then, in directories given by the environment variable ``LIBRARY_PATH`` (in left-to-right order). Distributing Extensions compiled with Cython ============================================ When your :pypi:`Cython` extension modules *are declared using the* :class:`setuptools.Extension` *class*, ``setuptools`` will detect at build time whether Cython is installed or not. If Cython is present, then ``setuptools`` will use it to build the ``.pyx`` files. Otherwise, ``setuptools`` will try to find and compile the equivalent ``.c`` files (instead of ``.pyx``). These files can be generated using the `cython command line tool`_. You can ensure that Cython is always automatically installed into the build environment by including it as a :ref:`build dependency ` in your ``pyproject.toml``: .. code-block:: toml [build-system] requires = [..., "cython"] Alternatively, you can include the ``.c`` code that is pre-compiled by Cython into your source distribution, alongside the original ``.pyx`` files (this might save a few seconds when building from an ``sdist``). To improve version compatibility, you probably also want to include current ``.c`` files in your :wiki:`revision control system`, and rebuild them whenever you check changes in for the ``.pyx`` source files. This will ensure that people tracking your project will be able to build it without installing Cython, and that there will be no variation due to small differences in the generate C files. Please checkout our docs on :ref:`controlling files in the distribution` for more information. ---- Extension API Reference ======================= .. autoclass:: setuptools.Extension .. _Python docs about C/C++ extensions: https://docs.python.org/3/extending/extending.html .. _Cython: https://cython.readthedocs.io/en/stable/index.html .. _directory options: https://gcc.gnu.org/onlinedocs/gcc/Directory-Options.html .. _environment variables: https://gcc.gnu.org/onlinedocs/gcc/Environment-Variables.html .. _cython command line tool: https://cython.readthedocs.io/en/stable/src/userguide/source_files_and_compilation.html ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/extension.rst0000644000175100001730000003176214467657412021155 0ustar00runnerdocker.. _Creating ``distutils`` Extensions: Extending or Customizing Setuptools =================================== Setuptools design is based on the distutils_ package originally distributed as part of Python's standard library, effectively serving as its successor (as established in :pep:`632`). This means that ``setuptools`` strives to honor the extension mechanisms provided by ``distutils``, and allows developers to create third party packages that modify or augment the build process behavior. A simple way of doing that is to hook in new or existing commands and ``setup()`` arguments just by defining "entry points". These are mappings from command or argument names to a specification of where to import a handler from. (See the section on :ref:`Dynamic Discovery of Services and Plugins` for some more background on entry points). The following sections describe the most common procedures for extending the ``distutils`` functionality used by ``setuptools``. .. important:: Any entry-point defined in your ``setup.cfg``, ``setup.py`` or ``pyproject.toml`` files are not immediately available for use. Your package needs to be installed first, then ``setuptools`` will be able to access these entry points. For example consider a ``Project-A`` that defines entry points. When building ``Project-A``, these will not be available. If ``Project-B`` declares a :doc:`build system requirement ` on ``Project-A``, then ``setuptools`` will be able to use ``Project-A``' customizations. Customizing Commands -------------------- Both ``setuptools`` and ``distutils`` are structured around the *command design pattern*. This means that each main action executed when building a distribution package (such as creating a :term:`sdist ` or :term:`wheel`) correspond to the implementation of a Python class. Originally in ``distutils``, these commands would correspond to actual CLI arguments that could be passed to the ``setup.py`` script to trigger a different aspect of the build. In ``setuptools``, however, these command objects are just a design abstraction that encapsulate logic and help to organise the code. You can overwrite existing commands (or add new ones) by defining entry points in the ``distutils.commands`` group. For example, if you wanted to add a ``foo`` command, you might add something like this to your project: .. code-block:: ini # setup.cfg ... [options.entry_points] distutils.commands = foo = mypackage.some_module:foo Assuming, of course, that the ``foo`` class in ``mypackage.some_module`` is a ``setuptools.Command`` subclass (documented below). Once a project containing such entry points has been activated on ``sys.path``, (e.g. by running ``pip install``) the command(s) will be available to any ``setuptools``-based project. In fact, this is how setuptools' own commands are installed: the setuptools project's setup script defines entry points for them! The commands ``sdist``, ``build_py`` and ``build_ext`` are especially useful to customize ``setuptools`` builds. Note however that when overwriting existing commands, you should be very careful to maintain API compatibility. Custom commands should try to replicate the same overall behavior as the original classes, and when possible, even inherit from them. You should also consider handling exceptions such as ``CompileError``, ``LinkError``, ``LibError``, among others. These exceptions are available in the ``setuptools.errors`` module. .. autoclass:: setuptools.Command :members: Supporting sdists and editable installs in ``build`` sub-commands ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ``build`` sub-commands (like ``build_py`` and ``build_ext``) are encouraged to implement the following protocol: .. autoclass:: setuptools.command.build.SubCommand :members: Adding Arguments ---------------- .. warning:: Adding arguments to setup is discouraged as such arguments are only supported through imperative execution and not supported through declarative config. Sometimes, your commands may need additional arguments to the ``setup()`` call. You can enable this by defining entry points in the ``distutils.setup_keywords`` group. For example, if you wanted a ``setup()`` argument called ``bar_baz``, you might add something like this to your extension project: .. code-block:: ini # setup.cfg ... [options.entry_points] distutils.commands = foo = mypackage.some_module:foo distutils.setup_keywords = bar_baz = mypackage.some_module:validate_bar_baz The idea here is that the entry point defines a function that will be called to validate the ``setup()`` argument, if it's supplied. The ``Distribution`` object will have the initial value of the attribute set to ``None``, and the validation function will only be called if the ``setup()`` call sets it to a non-``None`` value. Here's an example validation function:: def assert_bool(dist, attr, value): """Verify that value is True, False, 0, or 1""" if bool(value) != value: raise SetupError( "%r must be a boolean value (got %r)" % (attr,value) ) Your function should accept three arguments: the ``Distribution`` object, the attribute name, and the attribute value. It should raise a ``SetupError`` (from the ``setuptools.errors`` module) if the argument is invalid. Remember, your function will only be called with non-``None`` values, and the default value of arguments defined this way is always ``None``. So, your commands should always be prepared for the possibility that the attribute will be ``None`` when they access it later. If more than one active distribution defines an entry point for the same ``setup()`` argument, *all* of them will be called. This allows multiple extensions to define a common argument, as long as they agree on what values of that argument are valid. Customizing Distribution Options -------------------------------- Plugins may wish to extend or alter the options on a ``Distribution`` object to suit the purposes of that project. For example, a tool that infers the ``Distribution.version`` from SCM-metadata may need to hook into the option finalization. To enable this feature, Setuptools offers an entry point ``setuptools.finalize_distribution_options``. That entry point must be a callable taking one argument (the ``Distribution`` instance). If the callable has an ``.order`` property, that value will be used to determine the order in which the hook is called. Lower numbers are called first and the default is zero (0). Plugins may read, alter, and set properties on the distribution, but each plugin is encouraged to load the configuration/settings for their behavior independently. Defining Additional Metadata ---------------------------- Some extensible applications and frameworks may need to define their own kinds of metadata, which they can then access using the :mod:`importlib.metadata` APIs. Ordinarily, this is done by having plugin developers include additional files in their ``ProjectName.egg-info`` directory. However, since it can be tedious to create such files by hand, you may want to create an extension that will create the necessary files from arguments to ``setup()``, in much the same way that ``setuptools`` does for many of the ``setup()`` arguments it adds. See the section below for more details. .. _Adding new EGG-INFO Files: Adding new EGG-INFO Files ~~~~~~~~~~~~~~~~~~~~~~~~~ Some extensible applications or frameworks may want to allow third parties to develop plugins with application or framework-specific metadata included in the plugins' EGG-INFO directory, for easy access via the ``pkg_resources`` metadata API. The easiest way to allow this is to create an extension to be used from the plugin projects' setup scripts (via ``setup_requires``) that defines a new setup keyword, and then uses that data to write an EGG-INFO file when the ``egg_info`` command is run. The ``egg_info`` command looks for extension points in an ``egg_info.writers`` group, and calls them to write the files. Here's a simple example of an extension defining a setup argument ``foo_bar``, which is a list of lines that will be written to ``foo_bar.txt`` in the EGG-INFO directory of any project that uses the argument: .. code-block:: ini # setup.cfg ... [options.entry_points] distutils.setup_keywords = foo_bar = setuptools.dist:assert_string_list egg_info.writers = foo_bar.txt = setuptools.command.egg_info:write_arg This simple example makes use of two utility functions defined by setuptools for its own use: a routine to validate that a setup keyword is a sequence of strings, and another one that looks up a setup argument and writes it to a file. Here's what the writer utility looks like:: def write_arg(cmd, basename, filename): argname = os.path.splitext(basename)[0] value = getattr(cmd.distribution, argname, None) if value is not None: value = "\n".join(value) + "\n" cmd.write_or_delete_file(argname, filename, value) As you can see, ``egg_info.writers`` entry points must be a function taking three arguments: a ``egg_info`` command instance, the basename of the file to write (e.g. ``foo_bar.txt``), and the actual full filename that should be written to. In general, writer functions should honor the command object's ``dry_run`` setting when writing files, and use ``logging`` to do any console output. The easiest way to conform to this requirement is to use the ``cmd`` object's ``write_file()``, ``delete_file()``, and ``write_or_delete_file()`` methods exclusively for your file operations. See those methods' docstrings for more details. .. _Adding Support for Revision Control Systems: Adding Support for Revision Control Systems ------------------------------------------------- If the files you want to include in the source distribution are tracked using Git, Mercurial or SVN, you can use the following packages to achieve that: - Git and Mercurial: :pypi:`setuptools_scm` - SVN: :pypi:`setuptools_svn` If you would like to create a plugin for ``setuptools`` to find files tracked by another revision control system, you can do so by adding an entry point to the ``setuptools.file_finders`` group. The entry point should be a function accepting a single directory name, and should yield all the filenames within that directory (and any subdirectories thereof) that are under revision control. For example, if you were going to create a plugin for a revision control system called "foobar", you would write a function something like this: .. code-block:: python def find_files_for_foobar(dirname): ... # loop to yield paths that start with `dirname` And you would register it in a setup script using something like this: .. code-block:: ini # setup.cfg ... [options.entry_points] setuptools.file_finders = foobar = my_foobar_module:find_files_for_foobar Then, anyone who wants to use your plugin can simply install it, and their local setuptools installation will be able to find the necessary files. It is not necessary to distribute source control plugins with projects that simply use the other source control system, or to specify the plugins in ``setup_requires``. When you create a source distribution with the ``sdist`` command, setuptools automatically records what files were found in the ``SOURCES.txt`` file. That way, recipients of source distributions don't need to have revision control at all. However, if someone is working on a package by checking out with that system, they will need the same plugin(s) that the original author is using. A few important points for writing revision control file finders: * Your finder function MUST return relative paths, created by appending to the passed-in directory name. Absolute paths are NOT allowed, nor are relative paths that reference a parent directory of the passed-in directory. * Your finder function MUST accept an empty string as the directory name, meaning the current directory. You MUST NOT convert this to a dot; just yield relative paths. So, yielding a subdirectory named ``some/dir`` under the current directory should NOT be rendered as ``./some/dir`` or ``/somewhere/some/dir``, but *always* as simply ``some/dir`` * Your finder function SHOULD NOT raise any errors, and SHOULD deal gracefully with the absence of needed programs (i.e., ones belonging to the revision control system itself. It *may*, however, use ``logging.warning()`` to inform the user of the missing program(s). .. _distutils: https://docs.python.org/3.9/library/distutils.html Final Remarks ------------- * To use a ``setuptools`` plugin, your users will need to add your package as a build requirement to their build-system configuration. Please check out our guides on :doc:`/userguide/dependency_management` for more information. * Directly calling ``python setup.py ...`` is considered a **deprecated** practice. You should not add new commands to ``setuptools`` expecting them to be run via this interface. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/index.rst0000644000175100001730000000314514467657412020242 0ustar00runnerdocker================================================== Building and Distributing Packages with Setuptools ================================================== The first step towards sharing a Python library or program is to build a distribution package [#package-overload]_. This includes adding a set of additional files containing metadata and configuration to not only instruct ``setuptools`` on how the distribution should be built but also to help installer (such as :pypi:`pip`) during the installation process. This document contains information to help Python developers through this process. Please check the :doc:`/userguide/quickstart` for an overview of the workflow. Also note that ``setuptools`` is what is known in the community as :pep:`build backend <517#terminology-and-goals>`, user facing interfaces are provided by tools such as :pypi:`pip` and :pypi:`build`. To use ``setuptools``, one must explicitly create a ``pyproject.toml`` file as described :doc:`/build_meta`. Contents ======== .. toctree:: :maxdepth: 1 quickstart package_discovery dependency_management development_mode entry_point datafiles ext_modules distribution miscellaneous extension declarative_config pyproject_config --- .. rubric:: Notes .. [#package-overload] A :term:`Distribution Package` is also referred in the Python community simply as "package" Unfortunately, this jargon might be a bit confusing for new users because the term package can also to refer any :term:`directory ` (or sub directory) used to organize :term:`modules ` and auxiliary files. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/miscellaneous.rst0000644000175100001730000001036214467657412021775 0ustar00runnerdocker.. _Controlling files in the distribution: Controlling files in the distribution ===================================== For the most common use cases, ``setuptools`` will automatically find out which files are necessary for distributing the package. These include all :term:`pure Python modules ` in the ``py_modules`` or ``packages`` configuration, and the C sources (but not C headers) listed as part of extensions when creating a :term:`source distribution (or "sdist")`. However, when building more complex packages (e.g. packages that include non-Python files, or that need to use custom C headers), you might find that not all files present in your project folder are included in package :term:`distribution archive `. If you are using a :wiki:`Revision Control System`, such as git_ or mercurial_, and your source distributions only need to include files that you're tracking in revision control, you can use a ``setuptools`` :ref:`plugin `, such as :pypi:`setuptools-scm` or :pypi:`setuptools-svn` to automatically include all tracked files into the ``sdist``. .. _Using MANIFEST.in: Alternatively, if you need finer control over the files (e.g. you don't want to distribute :wiki:`CI/CD`-related files) or you need automatically generated files, you can add a ``MANIFEST.in`` file at the root of your project, to specify any files that the default file location algorithm doesn't catch. This file contains instructions that tell ``setuptools`` which files exactly should be part of the ``sdist`` (or not). A comprehensive guide to ``MANIFEST.in`` syntax is available at the :doc:`PyPA's Packaging User Guide `. .. attention:: Please note that ``setuptools`` supports the ``MANIFEST.in``, and not ``MANIFEST`` (no extension). Any documentation, tutorial or example that recommends using ``MANIFEST`` (no extension) is likely outdated. .. tip:: The ``MANIFEST.in`` file contains commands that allow you to discover and manipulate lists of files. There are many commands that can be used with different objectives, but you should try to not make your ``MANIFEST.in`` file too fine grained. A good idea is to start with a ``graft`` command (to add all files inside a set of directories) and then fine tune the file selection by removing the excess or adding isolated files. An example of ``MANIFEST.in`` for a simple project that organized according to a :ref:`src-layout` is: .. code-block:: bash # MANIFEST.in -- just for illustration graft src graft tests graft docs # `-> adds all files inside a directory include tox.ini # `-> matches file paths relative to the root of the project global-exclude *~ *.py[cod] *.so # `-> matches file names (regardless of directory) Once the correct files are present in the ``sdist``, they can then be used by binary extensions during the build process, or included in the final :term:`wheel ` [#build-process]_ if you configure ``setuptools`` with ``include_package_data=True``. .. important:: Please note that, when using ``include_package_data=True``, only files **inside the package directory** are included in the final ``wheel``, by default. So for example, if you create a :term:`Python project ` that uses :pypi:`setuptools-scm` and have a ``tests`` directory outside of the package folder, the ``tests`` directory will be present in the ``sdist`` but not in the ``wheel`` [#wheel-vs-sdist]_. See :doc:`/userguide/datafiles` for more information. ---- .. [#build-process] You can think about the build process as two stages: first the ``sdist`` will be created and then the ``wheel`` will be produced from that ``sdist``. .. [#wheel-vs-sdist] This happens because the ``sdist`` can contain files that are useful during development or the build process itself, but not in runtime (e.g. tests, docs, examples, etc...). The ``wheel``, on the other hand, is a file format that has been optimized and is ready to be unpacked into a running installation of Python or :term:`Virtual Environment`. Therefore it only contains items that are required during runtime. .. _git: https://git-scm.com .. _mercurial: https://www.mercurial-scm.org ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/package_discovery.rst0000644000175100001730000004356314467657412022625 0ustar00runnerdocker.. _`package_discovery`: ======================================== Package Discovery and Namespace Packages ======================================== .. note:: a full specification for the keywords supplied to ``setup.cfg`` or ``setup.py`` can be found at :doc:`keywords reference ` .. important:: The examples provided here are only to demonstrate the functionality introduced. More metadata and options arguments need to be supplied if you want to replicate them on your system. If you are completely new to setuptools, the :doc:`quickstart` section is a good place to start. ``Setuptools`` provides powerful tools to handle package discovery, including support for namespace packages. Normally, you would specify the packages to be included manually in the following manner: .. tab:: setup.cfg .. code-block:: ini [options] #... packages = mypkg mypkg.subpkg1 mypkg.subpkg2 .. tab:: setup.py .. code-block:: python setup( # ... packages=['mypkg', 'mypkg.subpkg1', 'mypkg.subpkg2'] ) .. tab:: pyproject.toml .. code-block:: toml # ... [tool.setuptools] packages = ["mypkg", "mypkg.subpkg1", "mypkg.subpkg2"] # ... If your packages are not in the root of the repository or do not correspond exactly to the directory structure, you also need to configure ``package_dir``: .. tab:: setup.cfg .. code-block:: ini [options] # ... package_dir = = src # directory containing all the packages (e.g. src/mypkg, src/mypkg/subpkg1, ...) # OR package_dir = mypkg = lib # mypkg.module corresponds to lib/module.py mypkg.subpkg1 = lib1 # mypkg.subpkg1.module1 corresponds to lib1/module1.py mypkg.subpkg2 = lib2 # mypkg.subpkg2.module2 corresponds to lib2/module2.py # ... .. tab:: setup.py .. code-block:: python setup( # ... package_dir = {"": "src"} # directory containing all the packages (e.g. src/mypkg, src/mypkg/subpkg1, ...) ) # OR setup( # ... package_dir = { "mypkg": "lib", # mypkg.module corresponds to lib/module.py "mypkg.subpkg1": "lib1", # mypkg.subpkg1.module1 corresponds to lib1/module1.py "mypkg.subpkg2": "lib2" # mypkg.subpkg2.module2 corresponds to lib2/module2.py # ... ) .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools] # ... package-dir = {"" = "src"} # directory containing all the packages (e.g. src/mypkg1, src/mypkg2) # OR [tool.setuptools.package-dir] mypkg = "lib" # mypkg.module corresponds to lib/module.py "mypkg.subpkg1" = "lib1" # mypkg.subpkg1.module1 corresponds to lib1/module1.py "mypkg.subpkg2" = "lib2" # mypkg.subpkg2.module2 corresponds to lib2/module2.py # ... This can get tiresome really quickly. To speed things up, you can rely on setuptools automatic discovery, or use the provided tools, as explained in the following sections. .. important:: Although ``setuptools`` allows developers to create a very complex mapping between directory names and package names, it is better to *keep it simple* and reflect the desired package hierarchy in the directory structure, preserving the same names. .. _auto-discovery: Automatic discovery =================== By default ``setuptools`` will consider 2 popular project layouts, each one with its own set of advantages and disadvantages [#layout1]_ [#layout2]_ as discussed in the following sections. Setuptools will automatically scan your project directory looking for these layouts and try to guess the correct values for the :ref:`packages ` and :doc:`py_modules ` configuration. .. important:: Automatic discovery will **only** be enabled if you **don't** provide any configuration for ``packages`` and ``py_modules``. If at least one of them is explicitly set, automatic discovery will not take place. **Note**: specifying ``ext_modules`` might also prevent auto-discover from taking place, unless your opt into :doc:`pyproject_config` (which will disable the backward compatible behaviour). .. _src-layout: src-layout ---------- The project should contain a ``src`` directory under the project root and all modules and packages meant for distribution are placed inside this directory:: project_root_directory ├── pyproject.toml # AND/OR setup.cfg, setup.py ├── ... └── src/ └── mypkg/ ├── __init__.py ├── ... ├── module.py ├── subpkg1/ │   ├── __init__.py │   ├── ... │   └── module1.py └── subpkg2/ ├── __init__.py ├── ... └── module2.py This layout is very handy when you wish to use automatic discovery, since you don't have to worry about other Python files or folders in your project root being distributed by mistake. In some circumstances it can be also less error-prone for testing or when using :pep:`420`-style packages. On the other hand you cannot rely on the implicit ``PYTHONPATH=.`` to fire up the Python REPL and play with your package (you will need an `editable install`_ to be able to do that). .. _flat-layout: flat-layout ----------- *(also known as "adhoc")* The package folder(s) are placed directly under the project root:: project_root_directory ├── pyproject.toml # AND/OR setup.cfg, setup.py ├── ... └── mypkg/ ├── __init__.py ├── ... ├── module.py ├── subpkg1/ │   ├── __init__.py │   ├── ... │   └── module1.py └── subpkg2/ ├── __init__.py ├── ... └── module2.py This layout is very practical for using the REPL, but in some situations it can be more error-prone (e.g. during tests or if you have a bunch of folders or Python files hanging around your project root). To avoid confusion, file and folder names that are used by popular tools (or that correspond to well-known conventions, such as distributing documentation alongside the project code) are automatically filtered out in the case of *flat-layout*: .. autoattribute:: setuptools.discovery.FlatLayoutPackageFinder.DEFAULT_EXCLUDE .. autoattribute:: setuptools.discovery.FlatLayoutModuleFinder.DEFAULT_EXCLUDE .. warning:: If you are using auto-discovery with *flat-layout*, ``setuptools`` will refuse to create :term:`distribution archives ` with multiple top-level packages or modules. This is done to prevent common errors such as accidentally publishing code not meant for distribution (e.g. maintenance-related scripts). Users that purposefully want to create multi-package distributions are advised to use :ref:`custom-discovery` or the ``src-layout``. There is also a handy variation of the *flat-layout* for utilities/libraries that can be implemented with a single Python file: single-module distribution ^^^^^^^^^^^^^^^^^^^^^^^^^^ A standalone module is placed directly under the project root, instead of inside a package folder:: project_root_directory ├── pyproject.toml # AND/OR setup.cfg, setup.py ├── ... └── single_file_lib.py .. _custom-discovery: Custom discovery ================ If the automatic discovery does not work for you (e.g., you want to *include* in the distribution top-level packages with reserved names such as ``tasks``, ``example`` or ``docs``, or you want to *exclude* nested packages that would be otherwise included), you can use the provided tools for package discovery: .. tab:: setup.cfg .. code-block:: ini [options] packages = find: #or packages = find_namespace: .. tab:: setup.py .. code-block:: python from setuptools import find_packages # or from setuptools import find_namespace_packages .. tab:: pyproject.toml .. code-block:: toml # ... [tool.setuptools.packages] find = {} # Scanning implicit namespaces is active by default # OR find = {namespaces = false} # Disable implicit namespaces Finding simple packages ----------------------- Let's start with the first tool. ``find:`` (``find_packages()``) takes a source directory and two lists of package name patterns to exclude and include, and then returns a list of ``str`` representing the packages it could find. To use it, consider the following directory:: mypkg ├── pyproject.toml # AND/OR setup.cfg, setup.py └── src ├── pkg1 │   └── __init__.py ├── pkg2 │   └── __init__.py ├── additional │   └── __init__.py └── pkg └── namespace └── __init__.py To have setuptools to automatically include packages found in ``src`` that start with the name ``pkg`` and not ``additional``: .. tab:: setup.cfg .. code-block:: ini [options] packages = find: package_dir = =src [options.packages.find] where = src include = pkg* # alternatively: `exclude = additional*` .. note:: ``pkg`` does not contain an ``__init__.py`` file, therefore ``pkg.namespace`` is ignored by ``find:`` (see ``find_namespace:`` below). .. tab:: setup.py .. code-block:: python setup( # ... packages=find_packages( where='src', include=['pkg*'], # alternatively: `exclude=['additional*']` ), package_dir={"": "src"} # ... ) .. note:: ``pkg`` does not contain an ``__init__.py`` file, therefore ``pkg.namespace`` is ignored by ``find_packages()`` (see ``find_namespace_packages()`` below). .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools.packages.find] where = ["src"] include = ["pkg*"] # alternatively: `exclude = ["additional*"]` namespaces = false .. note:: When using ``tool.setuptools.packages.find`` in ``pyproject.toml``, setuptools will consider :pep:`implicit namespaces <420>` by default when scanning your project directory. To avoid ``pkg.namespace`` from being added to your package list you can set ``namespaces = false``. This will prevent any folder without an ``__init__.py`` file from being scanned. .. important:: ``include`` and ``exclude`` accept strings representing :mod:`glob` patterns. These patterns should match the **full** name of the Python module (as if it was written in an ``import`` statement). For example if you have ``util`` pattern, it will match ``util/__init__.py`` but not ``util/files/__init__.py``. The fact that the parent package is matched by the pattern will not dictate if the submodule will be included or excluded from the distribution. You will need to explicitly add a wildcard (e.g. ``util*``) if you want the pattern to also match submodules. .. _Namespace Packages: Finding namespace packages -------------------------- ``setuptools`` provides ``find_namespace:`` (``find_namespace_packages()``) which behaves similarly to ``find:`` but works with namespace packages. Before diving in, it is important to have a good understanding of what :pep:`namespace packages <420>` are. Here is a quick recap. When you have two packages organized as follows: .. code-block:: bash /Users/Desktop/timmins/foo/__init__.py /Library/timmins/bar/__init__.py If both ``Desktop`` and ``Library`` are on your ``PYTHONPATH``, then a namespace package called ``timmins`` will be created automatically for you when you invoke the import mechanism, allowing you to accomplish the following: .. code-block:: pycon >>> import timmins.foo >>> import timmins.bar as if there is only one ``timmins`` on your system. The two packages can then be distributed separately and installed individually without affecting the other one. Now, suppose you decide to package the ``foo`` part for distribution and start by creating a project directory organized as follows:: foo ├── pyproject.toml # AND/OR setup.cfg, setup.py └── src └── timmins └── foo └── __init__.py If you want the ``timmins.foo`` to be automatically included in the distribution, then you will need to specify: .. tab:: setup.cfg .. code-block:: ini [options] package_dir = =src packages = find_namespace: [options.packages.find] where = src ``find:`` won't work because ``timmins`` doesn't contain ``__init__.py`` directly, instead, you have to use ``find_namespace:``. You can think of ``find_namespace:`` as identical to ``find:`` except it would count a directory as a package even if it doesn't contain ``__init__.py`` file directly. .. tab:: setup.py .. code-block:: python setup( # ... packages=find_namespace_packages(where='src'), package_dir={"": "src"} # ... ) When you use ``find_packages()``, all directories without an ``__init__.py`` file will be ignored. On the other hand, ``find_namespace_packages()`` will scan all directories. .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools.packages.find] where = ["src"] When using ``tool.setuptools.packages.find`` in ``pyproject.toml``, setuptools will consider :pep:`implicit namespaces <420>` by default when scanning your project directory. After installing the package distribution, ``timmins.foo`` would become available to your interpreter. .. warning:: Please have in mind that ``find_namespace:`` (setup.cfg), ``find_namespace_packages()`` (setup.py) and ``find`` (pyproject.toml) will scan **all** folders that you have in your project directory if you use a :ref:`flat-layout`. If used naïvely, this might result in unwanted files being added to your final wheel. For example, with a project directory organized as follows:: foo ├── docs │ └── conf.py ├── timmins │ └── foo │ └── __init__.py └── tests └── tests_foo └── __init__.py final users will end up installing not only ``timmins.foo``, but also ``docs`` and ``tests.tests_foo``. A simple way to fix this is to adopt the aforementioned :ref:`src-layout`, or make sure to properly configure the ``include`` and/or ``exclude`` accordingly. .. tip:: After :ref:`building your package `, you can have a look if all the files are correct (nothing missing or extra), by running the following commands: .. code-block:: bash tar tf dist/*.tar.gz unzip -l dist/*.whl This requires the ``tar`` and ``unzip`` to be installed in your OS. On Windows you can also use a GUI program such as 7zip_. Legacy Namespace Packages ========================= The fact you can create namespace packages so effortlessly above is credited to :pep:`420`. It used to be more cumbersome to accomplish the same result. Historically, there were two methods to create namespace packages. One is the ``pkg_resources`` style supported by ``setuptools`` and the other one being ``pkgutils`` style offered by ``pkgutils`` module in Python. Both are now considered *deprecated* despite the fact they still linger in many existing packages. These two differ in many subtle yet significant aspects and you can find out more on `Python packaging user guide `_. ``pkg_resource`` style namespace package ---------------------------------------- This is the method ``setuptools`` directly supports. Starting with the same layout, there are two pieces you need to add to it. First, an ``__init__.py`` file directly under your namespace package directory that contains the following: .. code-block:: python __import__("pkg_resources").declare_namespace(__name__) And the ``namespace_packages`` keyword in your ``setup.cfg`` or ``setup.py``: .. tab:: setup.cfg .. code-block:: ini [options] namespace_packages = timmins .. tab:: setup.py .. code-block:: python setup( # ... namespace_packages=['timmins'] ) And your directory should look like this .. code-block:: bash foo ├── pyproject.toml # AND/OR setup.cfg, setup.py └── src └── timmins ├── __init__.py └── foo └── __init__.py Repeat the same for other packages and you can achieve the same result as the previous section. ``pkgutil`` style namespace package ----------------------------------- This method is almost identical to the ``pkg_resource`` except that the ``namespace_packages`` declaration is omitted and the ``__init__.py`` file contains the following: .. code-block:: python __path__ = __import__('pkgutil').extend_path(__path__, __name__) The project layout remains the same and ``pyproject.toml/setup.cfg`` remains the same. ---- .. [#layout1] https://blog.ionelmc.ro/2014/05/25/python-packaging/#the-structure .. [#layout2] https://blog.ionelmc.ro/2017/09/25/rehashing-the-src-layout/ .. _editable install: https://pip.pypa.io/en/stable/cli/pip_install/#editable-installs .. _7zip: https://www.7-zip.org ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/pyproject_config.rst0000644000175100001730000003303214467657412022475 0ustar00runnerdocker.. _pyproject.toml config: ----------------------------------------------------- Configuring setuptools using ``pyproject.toml`` files ----------------------------------------------------- .. note:: New in 61.0.0 .. important:: If compatibility with legacy builds or versions of tools that don't support certain packaging standards (e.g. :pep:`517` or :pep:`660`), a simple ``setup.py`` script can be added to your project [#setupcfg-caveats]_ (while keeping the configuration in ``pyproject.toml``): .. code-block:: python from setuptools import setup setup() Starting with :pep:`621`, the Python community selected ``pyproject.toml`` as a standard way of specifying *project metadata*. ``Setuptools`` has adopted this standard and will use the information contained in this file as an input in the build process. The example below illustrates how to write a ``pyproject.toml`` file that can be used with ``setuptools``. It contains two TOML tables (identified by the ``[table-header]`` syntax): ``build-system`` and ``project``. The ``build-system`` table is used to tell the build frontend (e.g. :pypi:`build` or :pypi:`pip`) to use ``setuptools`` and any other plugins (e.g. ``setuptools-scm``) to build the package. The ``project`` table contains metadata fields as described by :doc:`PyPUG:specifications/declaring-project-metadata` guide. .. _example-pyproject-config: .. code-block:: toml [build-system] requires = ["setuptools", "setuptools-scm"] build-backend = "setuptools.build_meta" [project] name = "my_package" authors = [ {name = "Josiah Carberry", email = "josiah_carberry@brown.edu"}, ] description = "My package description" readme = "README.rst" requires-python = ">=3.7" keywords = ["one", "two"] license = {text = "BSD-3-Clause"} classifiers = [ "Framework :: Django", "Programming Language :: Python :: 3", ] dependencies = [ "requests", 'importlib-metadata; python_version<"3.8"', ] dynamic = ["version"] [project.optional-dependencies] pdf = ["ReportLab>=1.2", "RXP"] rest = ["docutils>=0.3", "pack ==1.1, ==1.3"] [project.scripts] my-script = "my_package.module:function" # ... other project metadata fields as specified in: # https://packaging.python.org/en/latest/specifications/declaring-project-metadata/ .. _setuptools-table: Setuptools-specific configuration ================================= While the standard ``project`` table in the ``pyproject.toml`` file covers most of the metadata used during the packaging process, there are still some ``setuptools``-specific configurations that can be set by users that require customization. These configurations are completely optional and probably can be skipped when creating simple packages. They are equivalent to the :doc:`/references/keywords` used by the ``setup.py`` file, and can be set via the ``tool.setuptools`` table: ========================= =========================== ========================= Key Value Type (TOML) Notes ========================= =========================== ========================= ``py-modules`` array See tip below. ``packages`` array or ``find`` directive See tip below. ``package-dir`` table/inline-table Used when explicitly/manually listing ``packages``. ------------------------- --------------------------- ------------------------- ``package-data`` table/inline-table See :doc:`/userguide/datafiles`. ``include-package-data`` boolean ``True`` by default (only when using ``pyproject.toml`` project metadata/config). See :doc:`/userguide/datafiles`. ``exclude-package-data`` table/inline-table Empty by default. See :doc:`/userguide/datafiles`. ------------------------- --------------------------- ------------------------- ``license-files`` array of glob patterns **Provisional** - likely to change with :pep:`639` (by default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``) ``data-files`` table/inline-table **Discouraged** - check :doc:`/userguide/datafiles`. Whenever possible, consider using data files inside the package directories. ``script-files`` array **Discouraged** - equivalent to the ``script`` keyword in ``setup.py``. Whenever possible, please use ``project.scripts`` instead. ------------------------- --------------------------- ------------------------- ``provides`` array *ignored by pip when installing packages* ``obsoletes`` array *ignored by pip when installing packages* ``platforms`` array Sets the ``Platform`` :doc:`core-metadata ` field (*ignored by pip when installing packages*). ------------------------- --------------------------- ------------------------- ``zip-safe`` boolean **Obsolete** - only relevant for ``pkg_resources``, ``easy_install`` and ``setup.py install`` in the context of :doc:`eggs ` (deprecated). ``eager-resources`` array **Obsolete** - only relevant for ``pkg_resources``, ``easy_install`` and ``setup.py install`` in the context of :doc:`eggs ` (deprecated). ``namespace-packages`` array **Deprecated** - use implicit namespaces instead (:pep:`420`). ========================= =========================== ========================= .. note:: The `TOML value types`_ ``array`` and ``table/inline-table`` are roughly equivalent to the Python's :obj:`list` and :obj:`dict` data types, respectively. Please note that some of these configurations are deprecated, obsolete or at least discouraged, but they are made available to ensure portability. Deprecated and obsolete configurations may be removed in future versions of ``setuptools``. New packages should avoid relying on discouraged fields if possible, and existing packages should consider migrating to alternatives. .. tip:: When both ``py-modules`` and ``packages`` are left unspecified, ``setuptools`` will attempt to perform :ref:`auto-discovery`, which should cover most popular project directory organization techniques, such as the :ref:`src-layout` and the :ref:`flat-layout`. However if your project does not follow these conventional layouts (e.g. you want to use a ``flat-layout`` but at the same time have custom directories at the root of your project), you might need to use the ``find`` directive [#directives]_ as shown below: .. code-block:: toml [tool.setuptools.packages.find] where = ["src"] # list of folders that contain the packages (["."] by default) include = ["my_package*"] # package names should match these glob patterns (["*"] by default) exclude = ["my_package.tests*"] # exclude packages matching these glob patterns (empty by default) namespaces = false # to disable scanning PEP 420 namespaces (true by default) Note that the glob patterns in the example above need to be matched by the **entire** package name. This means that if you specify ``exclude = ["tests"]``, modules like ``tests.my_package.test1`` will still be included in the distribution (to remove them, add a wildcard to the end of the pattern: ``"tests*"``). Alternatively, you can explicitly list the packages in modules: .. code-block:: toml [tool.setuptools] packages = ["my_package"] If you want to publish a distribution that does not include any Python module (e.g. a "meta-distribution" that just aggregate dependencies), please consider something like the following: .. code-block:: toml [tool.setuptools] packages = [] .. _dynamic-pyproject-config: Dynamic Metadata ================ Note that in the first example of this page we use ``dynamic`` to identify which metadata fields are dynamically computed during the build by either ``setuptools`` itself or the plugins installed via ``build-system.requires`` (e.g. ``setuptools-scm`` is capable of deriving the current project version directly from the ``git`` :wiki:`version control` system). Currently the following fields can be listed as dynamic: ``version``, ``classifiers``, ``description``, ``entry-points``, ``scripts``, ``gui-scripts`` and ``readme``. When these fields are expected to be provided by ``setuptools`` a corresponding entry is required in the ``tool.setuptools.dynamic`` table [#entry-points]_. For example: .. code-block:: toml # ... [project] name = "my_package" dynamic = ["version", "readme"] # ... [tool.setuptools.dynamic] version = {attr = "my_package.VERSION"} readme = {file = ["README.rst", "USAGE.rst"]} In the ``dynamic`` table, the ``attr`` directive [#directives]_ will read an attribute from the given module [#attr]_, while ``file`` will read the contents of all given files and concatenate them in a single string. ========================== =================== ================================================================================================= Key Directive Notes ========================== =================== ================================================================================================= ``version`` ``attr``, ``file`` ``readme`` ``file`` Here you can also set ``"content-type"``: ``readme = {file = ["README.txt", "USAGE.txt"], content-type = "text/plain"}`` If ``content-type`` is not given, ``"text/x-rst"`` is used by default. ``description`` ``file`` One-line text (no line breaks) ``classifiers`` ``file`` Multi-line text with one classifier per line ``entry-points`` ``file`` INI format following :doc:`PyPUG:specifications/entry-points` (``console_scripts`` and ``gui_scripts`` can be included) ``dependencies`` ``file`` *subset* of the ``requirements.txt`` format (``#`` comments and blank lines excluded) **BETA** ``optional-dependencies`` ``file`` *subset* of the ``requirements.txt`` format per group (``#`` comments and blank lines excluded) **BETA** ========================== =================== ================================================================================================= Supporting ``file`` for dependencies is meant for a convenience for packaging applications with possibly strictly versioned dependencies. Library packagers are discouraged from using overly strict (or "locked") dependency versions in their ``dependencies`` and ``optional-dependencies``. Currently, when specifying ``optional-dependencies`` dynamically, all of the groups must be specified dynamically; one can not specify some of them statically and some of them dynamically. Also note that the file format for specifying dependencies resembles a ``requirements.txt`` file, however please keep in mind that all non-comment lines must conform with :pep:`508` (``pip``-specify syntaxes, e.g. ``-c/-r/-e`` flags, are not supported). .. note:: If you are using an old version of ``setuptools``, you might need to ensure that all files referenced by the ``file`` directive are included in the ``sdist`` (you can do that via ``MANIFEST.in`` or using plugins such as ``setuptools-scm``, please have a look on :doc:`/userguide/miscellaneous` for more information). .. versionchanged:: 66.1.0 Newer versions of ``setuptools`` will automatically add these files to the ``sdist``. ---- .. rubric:: Notes .. [#setupcfg-caveats] ``pip`` may allow editable install only with ``pyproject.toml`` and ``setup.cfg``. However, this behavior may not be consistent over various ``pip`` versions and other packaging-related tools (``setup.py`` is more reliable on those scenarios). .. [#entry-points] Dynamic ``scripts`` and ``gui-scripts`` are a special case. When resolving these metadata keys, ``setuptools`` will look for ``tool.setuptools.dynamic.entry-points``, and use the values of the ``console_scripts`` and ``gui_scripts`` :doc:`entry-point groups `. .. [#directives] In the context of this document, *directives* are special TOML values that are interpreted differently by ``setuptools`` (usually triggering an associated function). Most of the times they correspond to a special TOML table (or inline-table) with a single top-level key. For example, you can have the ``{find = {where = ["src"], exclude=["tests*"]}}`` directive for ``tool.setuptools.packages``, or ``{attr = "mymodule.attr"}`` directive for ``tool.setuptools.dynamic.version``. .. [#attr] ``attr`` is meant to be used when the module attribute is statically specified (e.g. as a string, list or tuple). As a rule of thumb, the attribute should be able to be parsed with :func:`ast.literal_eval`, and should not be modified or re-assigned. .. _TOML value types: https://toml.io/en/v1.0.0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/docs/userguide/quickstart.rst0000644000175100001730000003771714467657412021341 0ustar00runnerdocker========== Quickstart ========== Installation ============ You can install the latest version of ``setuptools`` using :pypi:`pip`:: pip install --upgrade setuptools Most of the times, however, you don't have to... Instead, when creating new Python packages, it is recommended to use a command line tool called :pypi:`build`. This tool will automatically download ``setuptools`` and any other build-time dependencies that your project might have. You just need to specify them in a ``pyproject.toml`` file at the root of your package, as indicated in the :ref:`following section `. .. _install-build: You can also :doc:`install build ` using :pypi:`pip`:: pip install --upgrade build This will allow you to run the command: ``python -m build``. .. important:: Please note that some operating systems might be equipped with the ``python3`` and ``pip3`` commands instead of ``python`` and ``pip`` (but they should be equivalent). If you don't have ``pip`` or ``pip3`` available in your system, please check out :doc:`pip installation docs `. Every python package must provide a ``pyproject.toml`` and specify the backend (build system) it wants to use. The distribution can then be generated with whatever tool that provides a ``build sdist``-like functionality. .. _basic-use: Basic Use ========= When creating a Python package, you must provide a ``pyproject.toml`` file containing a ``build-system`` section similar to the example below: .. code-block:: toml [build-system] requires = ["setuptools"] build-backend = "setuptools.build_meta" This section declares what are your build system dependencies, and which library will be used to actually do the packaging. .. note:: Historically this documentation has unnecessarily listed ``wheel`` in the ``requires`` list, and many projects still do that. This is not recommended. The backend automatically adds ``wheel`` dependency when it is required, and listing it explicitly causes it to be unnecessarily required for source distribution builds. You should only include ``wheel`` in ``requires`` if you need to explicitly access it during build time (e.g. if your project needs a ``setup.py`` script that imports ``wheel``). In addition to specifying a build system, you also will need to add some package information such as metadata, contents, dependencies, etc. This can be done in the same ``pyproject.toml`` file, or in a separated one: ``setup.cfg`` or ``setup.py`` [#setup.py]_. The following example demonstrates a minimum configuration (which assumes the project depends on :pypi:`requests` and :pypi:`importlib-metadata` to be able to run): .. tab:: pyproject.toml .. code-block:: toml [project] name = "mypackage" version = "0.0.1" dependencies = [ "requests", 'importlib-metadata; python_version<"3.8"', ] See :doc:`/userguide/pyproject_config` for more information. .. tab:: setup.cfg .. code-block:: ini [metadata] name = mypackage version = 0.0.1 [options] install_requires = requests importlib-metadata; python_version < "3.8" See :doc:`/userguide/declarative_config` for more information. .. tab:: setup.py [#setup.py]_ .. code-block:: python from setuptools import setup setup( name='mypackage', version='0.0.1', install_requires=[ 'requests', 'importlib-metadata; python_version == "3.8"', ], ) See :doc:`/references/keywords` for more information. Finally, you will need to organize your Python code to make it ready for distributing into something that looks like the following (optional files marked with ``#``):: mypackage ├── pyproject.toml # and/or setup.cfg/setup.py (depending on the configuration method) | # README.rst or README.md (a nice description of your package) | # LICENCE (properly chosen license information, e.g. MIT, BSD-3, GPL-3, MPL-2, etc...) └── mypackage ├── __init__.py └── ... (other Python files) With :ref:`build installed in your system `, you can then run:: python -m build You now have your distribution ready (e.g. a ``tar.gz`` file and a ``.whl`` file in the ``dist`` directory), which you can :doc:`upload ` to PyPI_! Of course, before you release your project to PyPI_, you'll want to add a bit more information to help people find or learn about your project. And maybe your project will have grown by then to include a few dependencies, and perhaps some data files and scripts. In the next few sections, we will walk through the additional but essential information you need to specify to properly package your project. .. TODO: A previous generation of this document included a section called "Python packaging at a glance". This is a nice title, but the content removed because it assumed the reader had familiarity with the history of setuptools and PEP 517. We should take advantage of this nice title and add this section back, but use it to explain important concepts of the ecosystem, such as "sdist", "wheel", "index". It would also be nice if we could have a diagram for that (explaining for example that "wheels" are built from "sdists" not the source tree). .. _setuppy_discouraged: .. admonition:: Info: Using ``setup.py`` :class: seealso Setuptools offers first class support for ``setup.py`` files as a configuration mechanism. It is important to remember, however, that running this file as a script (e.g. ``python setup.py sdist``) is strongly **discouraged**, and that the majority of the command line interfaces are (or will be) **deprecated** (e.g. ``python setup.py install``, ``python setup.py bdist_wininst``, ...). We also recommend users to expose as much as possible configuration in a more *declarative* way via the :doc:`pyproject.toml ` or :doc:`setup.cfg `, and keep the ``setup.py`` minimal with only the dynamic parts (or even omit it completely if applicable). See `Why you shouldn't invoke setup.py directly`_ for more background. .. _Why you shouldn't invoke setup.py directly: https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html Overview ======== Package discovery ----------------- For projects that follow a simple directory structure, ``setuptools`` should be able to automatically detect all :term:`packages ` and :term:`namespaces `. However, complex projects might include additional folders and supporting files that not necessarily should be distributed (or that can confuse ``setuptools`` auto discovery algorithm). Therefore, ``setuptools`` provides a convenient way to customize which packages should be distributed and in which directory they should be found, as shown in the example below: .. tab:: pyproject.toml .. code-block:: toml # ... [tool.setuptools.packages] find = {} # Scan the project directory with the default parameters # OR [tool.setuptools.packages.find] # All the following settings are optional: where = ["src"] # ["."] by default include = ["mypackage*"] # ["*"] by default exclude = ["mypackage.tests*"] # empty by default namespaces = false # true by default .. tab:: setup.cfg .. code-block:: ini [options] packages = find: # OR `find_namespace:` if you want to use namespaces [options.packages.find] # (always `find` even if `find_namespace:` was used before) # This section is optional as well as each of the following options: where=src # . by default include=mypackage* # * by default exclude=mypackage.tests* # empty by default .. tab:: setup.py [#setup.py]_ .. code-block:: python from setuptools import find_packages # or find_namespace_packages setup( # ... packages=find_packages( # All keyword arguments below are optional: where='src', # '.' by default include=['mypackage*'], # ['*'] by default exclude=['mypackage.tests'], # empty by default ), # ... ) When you pass the above information, alongside other necessary information, ``setuptools`` walks through the directory specified in ``where`` (defaults to ``.``) and filters the packages it can find following the ``include`` patterns (defaults to ``*``), then it removes those that match the ``exclude`` patterns (defaults to empty) and returns a list of Python packages. For more details and advanced use, go to :ref:`package_discovery`. .. tip:: Starting with version 61.0.0, setuptools' automatic discovery capabilities have been improved to detect popular project layouts (such as the :ref:`flat-layout` and :ref:`src-layout`) without requiring any special configuration. Check out our :ref:`reference docs ` for more information. Entry points and automatic script creation ------------------------------------------- Setuptools supports automatic creation of scripts upon installation, that run code within your package if you specify them as :doc:`entry points `. An example of how this feature can be used in ``pip``: it allows you to run commands like ``pip install`` instead of having to type ``python -m pip install``. The following configuration examples show how to accomplish this: .. tab:: pyproject.toml .. code-block:: toml [project.scripts] cli-name = "mypkg.mymodule:some_func" .. tab:: setup.cfg .. code-block:: ini [options.entry_points] console_scripts = cli-name = mypkg.mymodule:some_func .. tab:: setup.py [#setup.py]_ .. code-block:: python setup( # ... entry_points={ 'console_scripts': [ 'cli-name = mypkg.mymodule:some_func', ] } ) When this project is installed, a ``cli-name`` executable will be created. ``cli-name`` will invoke the function ``some_func`` in the ``mypkg/mymodule.py`` file when called by the user. Note that you can also use the ``entry-points`` mechanism to advertise components between installed packages and implement plugin systems. For detailed usage, go to :doc:`entry_point`. Dependency management --------------------- Packages built with ``setuptools`` can specify dependencies to be automatically installed when the package itself is installed. The example below shows how to configure this kind of dependencies: .. tab:: pyproject.toml .. code-block:: toml [project] # ... dependencies = [ "docutils", "requests <= 0.4", ] # ... .. tab:: setup.cfg .. code-block:: ini [options] install_requires = docutils requests <= 0.4 .. tab:: setup.py [#setup.py]_ .. code-block:: python setup( # ... install_requires=["docutils", "requests <= 0.4"], # ... ) Each dependency is represented by a string that can optionally contain version requirements (e.g. one of the operators <, >, <=, >=, == or !=, followed by a version identifier), and/or conditional environment markers, e.g. ``sys_platform == "win32"`` (see :doc:`PyPUG:specifications/version-specifiers` for more information). When your project is installed, all of the dependencies not already installed will be located (via PyPI), downloaded, built (if necessary), and installed. This, of course, is a simplified scenario. You can also specify groups of extra dependencies that are not strictly required by your package to work, but that will provide additional functionalities. For more advanced use, see :doc:`dependency_management`. .. _Including Data Files: Including Data Files -------------------- Setuptools offers three ways to specify data files to be included in your packages. For the simplest use, you can simply use the ``include_package_data`` keyword: .. tab:: pyproject.toml .. code-block:: toml [tool.setuptools] include-package-data = true # This is already the default behaviour if you are using # pyproject.toml to configure your build. # You can deactivate that with `include-package-data = false` .. tab:: setup.cfg .. code-block:: ini [options] include_package_data = True .. tab:: setup.py [#setup.py]_ .. code-block:: python setup( # ... include_package_data=True, # ... ) This tells setuptools to install any data files it finds in your packages. The data files must be specified via the |MANIFEST.in|_ file or automatically added by a :ref:`Revision Control System plugin `. For more details, see :doc:`datafiles`. Development mode ---------------- ``setuptools`` allows you to install a package without copying any files to your interpreter directory (e.g. the ``site-packages`` directory). This allows you to modify your source code and have the changes take effect without you having to rebuild and reinstall. Here's how to do it:: pip install --editable . See :doc:`development_mode` for more information. .. tip:: Prior to :ref:`pip v21.1 `, a ``setup.py`` script was required to be compatible with development mode. With late versions of pip, projects without ``setup.py`` may be installed in this mode. If you have a version of ``pip`` older than v21.1 or is using a different packaging-related tool that does not support :pep:`660`, you might need to keep a ``setup.py`` file in file in your repository if you want to use editable installs. A simple script will suffice, for example: .. code-block:: python from setuptools import setup setup() You can still keep all the configuration in :doc:`pyproject.toml ` and/or :doc:`setup.cfg ` Uploading your package to PyPI ------------------------------ After generating the distribution files, the next step would be to upload your distribution so others can use it. This functionality is provided by :pypi:`twine` and is documented in the :doc:`Python packaging tutorial `. Transitioning from ``setup.py`` to ``setup.cfg`` ------------------------------------------------ To avoid executing arbitrary scripts and boilerplate code, we are transitioning into a full-fledged ``setup.cfg`` to declare your package information instead of running ``setup()``. This inevitably brings challenges due to a different syntax. :doc:`Here ` we provide a quick guide to understanding how ``setup.cfg`` is parsed by ``setuptools`` to ease the pain of transition. .. _packaging-resources: Resources on Python packaging ============================= Packaging in Python can be hard and is constantly evolving. `Python Packaging User Guide `_ has tutorials and up-to-date references that can help you when it is time to distribute your work. .. |MANIFEST.in| replace:: ``MANIFEST.in`` .. _MANIFEST.in: https://packaging.python.org/en/latest/guides/using-manifest-in/ ---- .. rubric:: Notes .. [#setup.py] New projects are advised to avoid ``setup.py`` configurations (beyond the minimal stub) when custom scripting during the build is not necessary. Examples are kept in this document to help people interested in maintaining or contributing to existing packages that use ``setup.py``. Note that you can still keep most of configuration declarative in :doc:`setup.cfg ` or :doc:`pyproject.toml ` and use ``setup.py`` only for the parts not supported in those files (e.g. C extensions). See :ref:`note `. .. _PyPI: https://pypi.org ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/exercises.py0000644000175100001730000000024314467657412016015 0ustar00runnerdockerdef measure_startup_perf(): # run by pytest_perf import subprocess import sys # end warmup subprocess.check_call([sys.executable, '-c', 'pass']) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/launcher.c0000644000175100001730000002470714467657412015431 0ustar00runnerdocker/* Setuptools Script Launcher for Windows This is a stub executable for Windows that functions somewhat like Effbot's "exemaker", in that it runs a script with the same name but a .py extension, using information from a #! line. It differs in that it spawns the actual Python executable, rather than attempting to hook into the Python DLL. This means that the script will run with sys.executable set to the Python executable, where exemaker ends up with sys.executable pointing to itself. (Which means it won't work if you try to run another Python process using sys.executable.) To build/rebuild with mingw32, do this in the setuptools project directory: gcc -DGUI=0 -mno-cygwin -O -s -o setuptools/cli.exe launcher.c gcc -DGUI=1 -mwindows -mno-cygwin -O -s -o setuptools/gui.exe launcher.c To build for Windows RT, install both Visual Studio Express for Windows 8 and for Windows Desktop (both freeware), create "win32" application using "Windows Desktop" version, create new "ARM" target via "Configuration Manager" menu and modify ".vcxproj" file by adding "true" tag as child of "PropertyGroup" tags that has "Debug|ARM" and "Release|ARM" properties. It links to msvcrt.dll, but this shouldn't be a problem since it doesn't actually run Python in the same process. Note that using 'exec' instead of 'spawn' doesn't work, because on Windows this leads to the Python executable running in the *background*, attached to the same console window, meaning you get a command prompt back *before* Python even finishes starting. So, we have to use spawnv() and wait for Python to exit before continuing. :( */ #include #include #include #include #include #include #include int child_pid=0; int fail(char *format, char *data) { /* Print error message to stderr and return 2 */ fprintf(stderr, format, data); return 2; } char *quoted(char *data) { int i, ln = strlen(data), nb; /* We allocate twice as much space as needed to deal with worse-case of having to escape everything. */ char *result = calloc(ln*2+3, sizeof(char)); char *presult = result; *presult++ = '"'; for (nb=0, i=0; i < ln; i++) { if (data[i] == '\\') nb += 1; else if (data[i] == '"') { for (; nb > 0; nb--) *presult++ = '\\'; *presult++ = '\\'; } else nb = 0; *presult++ = data[i]; } for (; nb > 0; nb--) /* Deal w trailing slashes */ *presult++ = '\\'; *presult++ = '"'; *presult++ = 0; return result; } char *loadable_exe(char *exename) { /* HINSTANCE hPython; DLL handle for python executable */ char *result; /* hPython = LoadLibraryEx(exename, NULL, LOAD_WITH_ALTERED_SEARCH_PATH); if (!hPython) return NULL; */ /* Return the absolute filename for spawnv */ result = calloc(MAX_PATH, sizeof(char)); strncpy(result, exename, MAX_PATH); /*if (result) GetModuleFileNameA(hPython, result, MAX_PATH); FreeLibrary(hPython); */ return result; } char *find_exe(char *exename, char *script) { char drive[_MAX_DRIVE], dir[_MAX_DIR], fname[_MAX_FNAME], ext[_MAX_EXT]; char path[_MAX_PATH], c, *result; /* convert slashes to backslashes for uniform search below */ result = exename; while (c = *result++) if (c=='/') result[-1] = '\\'; _splitpath(exename, drive, dir, fname, ext); if (drive[0] || dir[0]=='\\') { return loadable_exe(exename); /* absolute path, use directly */ } /* Use the script's parent directory, which should be the Python home (This should only be used for bdist_wininst-installed scripts, because easy_install-ed scripts use the absolute path to python[w].exe */ _splitpath(script, drive, dir, fname, ext); result = dir + strlen(dir) -1; if (*result == '\\') result--; while (*result != '\\' && result>=dir) *result-- = 0; _makepath(path, drive, dir, exename, NULL); return loadable_exe(path); } char **parse_argv(char *cmdline, int *argc) { /* Parse a command line in-place using MS C rules */ char **result = calloc(strlen(cmdline), sizeof(char *)); char *output = cmdline; char c; int nb = 0; int iq = 0; *argc = 0; result[0] = output; while (isspace(*cmdline)) cmdline++; /* skip leading spaces */ do { c = *cmdline++; if (!c || (isspace(c) && !iq)) { while (nb) {*output++ = '\\'; nb--; } *output++ = 0; result[++*argc] = output; if (!c) return result; while (isspace(*cmdline)) cmdline++; /* skip leading spaces */ if (!*cmdline) return result; /* avoid empty arg if trailing ws */ continue; } if (c == '\\') ++nb; /* count \'s */ else { if (c == '"') { if (!(nb & 1)) { iq = !iq; c = 0; } /* skip " unless odd # of \ */ nb = nb >> 1; /* cut \'s in half */ } while (nb) {*output++ = '\\'; nb--; } if (c) *output++ = c; } } while (1); } void pass_control_to_child(DWORD control_type) { /* * distribute-issue207 * passes the control event to child process (Python) */ if (!child_pid) { return; } GenerateConsoleCtrlEvent(child_pid,0); } BOOL control_handler(DWORD control_type) { /* * distribute-issue207 * control event handler callback function */ switch (control_type) { case CTRL_C_EVENT: pass_control_to_child(0); break; } return TRUE; } int create_and_wait_for_subprocess(char* command) { /* * distribute-issue207 * launches child process (Python) */ DWORD return_value = 0; LPSTR commandline = command; STARTUPINFOA s_info; PROCESS_INFORMATION p_info; ZeroMemory(&p_info, sizeof(p_info)); ZeroMemory(&s_info, sizeof(s_info)); s_info.cb = sizeof(STARTUPINFO); // set-up control handler callback function SetConsoleCtrlHandler((PHANDLER_ROUTINE) control_handler, TRUE); if (!CreateProcessA(NULL, commandline, NULL, NULL, TRUE, 0, NULL, NULL, &s_info, &p_info)) { fprintf(stderr, "failed to create process.\n"); return 0; } child_pid = p_info.dwProcessId; // wait for Python to exit WaitForSingleObject(p_info.hProcess, INFINITE); if (!GetExitCodeProcess(p_info.hProcess, &return_value)) { fprintf(stderr, "failed to get exit code from process.\n"); return 0; } return return_value; } char* join_executable_and_args(char *executable, char **args, int argc) { /* * distribute-issue207 * CreateProcess needs a long string of the executable and command-line arguments, * so we need to convert it from the args that was built */ int len,counter; char* cmdline; len=strlen(executable)+2; for (counter=1; counterscript && *end != '.') *end-- = '\0'; *end-- = '\0'; strcat(script, (GUI ? "-script.pyw" : "-script.py")); /* figure out the target python executable */ scriptf = open(script, O_RDONLY); if (scriptf == -1) { return fail("Cannot open %s\n", script); } end = python + read(scriptf, python, sizeof(python)); close(scriptf); ptr = python-1; while(++ptr < end && *ptr && *ptr!='\n' && *ptr!='\r') {;} *ptr-- = '\0'; if (strncmp(python, "#!", 2)) { /* default to python.exe if no #! header */ strcpy(python, "#!python.exe"); } parsedargs = parse_argv(python+2, &parsedargc); /* Using spawnv() can fail strangely if you e.g. find the Cygwin Python, so we'll make sure Windows can find and load it */ ptr = find_exe(parsedargs[0], script); if (!ptr) { return fail("Cannot find Python executable %s\n", parsedargs[0]); } /* printf("Python executable: %s\n", ptr); */ /* Argument array needs to be parsedargc + argc, plus 1 for null sentinel */ newargs = (char **)calloc(parsedargc + argc + 1, sizeof(char *)); newargsp = newargs; *newargsp++ = quoted(ptr); for (i = 1; i..rst`` pattern, where the categories are: - ``feature``: Any backwards compatible code change - ``bugfix``: A fix for broken behavior of a previous change - ``doc``: A change to the documentation - ``removal``: Any backwards-compatibility breaking change - ``misc``: Changes internal to the repo like CI, test and build changes A pull request may have more than one of these components, for example a code change may introduce a new feature that deprecates an old feature, in which case two fragments should be added. It is not necessary to make a separate documentation fragment for documentation changes accompanying the relevant code changes. Examples for adding changelog entries to your Pull Requests ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ File :file:`newsfragments/2395.doc.1.rst`: .. code-block:: rst Added a ``:user:`` role to Sphinx config -- by :user:`webknjaz` File :file:`newsfragments/1354.misc.rst`: .. code-block:: rst Added ``towncrier`` for changelog management -- by :user:`pganssle` File :file:`newsfragments/2355.feature.rst`: .. code-block:: rst When pip is imported as part of a build, leave :py:mod:`distutils` patched -- by :user:`jaraco` .. tip:: See :file:`towncrier.toml` for all available categories (``tool.towncrier.type``). .. _Towncrier philosophy: https://towncrier.readthedocs.io/en/latest/#philosophy ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.491548 setuptools-68.1.2/pkg_resources/0000755000175100001730000000000014467657443016331 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/__init__.py0000644000175100001730000032556514467657412020456 0ustar00runnerdocker""" Package resource API -------------------- A resource is a logical file contained within a package, or a logical subdirectory thereof. The package resource API expects resource names to have their path parts separated with ``/``, *not* whatever the local path separator is. Do not use os.path operations to manipulate resource names being passed into the API. The package resource API is designed to work with normal filesystem packages, .egg files, and unpacked .egg files. It can also work in a limited way with .zip files and with custom PEP 302 loaders that support the ``get_data()`` method. This module is deprecated. Users are directed to :mod:`importlib.resources`, :mod:`importlib.metadata` and :pypi:`packaging` instead. """ import sys import os import io import time import re import types import zipfile import zipimport import warnings import stat import functools import pkgutil import operator import platform import collections import plistlib import email.parser import errno import tempfile import textwrap import inspect import ntpath import posixpath import importlib from pkgutil import get_importer try: import _imp except ImportError: # Python 3.2 compatibility import imp as _imp try: FileExistsError except NameError: FileExistsError = OSError # capture these to bypass sandboxing from os import utime try: from os import mkdir, rename, unlink WRITE_SUPPORT = True except ImportError: # no write support, probably under GAE WRITE_SUPPORT = False from os import open as os_open from os.path import isdir, split try: import importlib.machinery as importlib_machinery # access attribute to force import under delayed import mechanisms. importlib_machinery.__name__ except ImportError: importlib_machinery = None from pkg_resources.extern.jaraco.text import ( yield_lines, drop_comment, join_continuation, ) from pkg_resources.extern import platformdirs from pkg_resources.extern import packaging __import__('pkg_resources.extern.packaging.version') __import__('pkg_resources.extern.packaging.specifiers') __import__('pkg_resources.extern.packaging.requirements') __import__('pkg_resources.extern.packaging.markers') __import__('pkg_resources.extern.packaging.utils') if sys.version_info < (3, 5): raise RuntimeError("Python 3.5 or later is required") # declare some globals that will be defined later to # satisfy the linters. require = None working_set = None add_activation_listener = None resources_stream = None cleanup_resources = None resource_dir = None resource_stream = None set_extraction_path = None resource_isdir = None resource_string = None iter_entry_points = None resource_listdir = None resource_filename = None resource_exists = None _distribution_finders = None _namespace_handlers = None _namespace_packages = None warnings.warn( "pkg_resources is deprecated as an API. " "See https://setuptools.pypa.io/en/latest/pkg_resources.html", DeprecationWarning, stacklevel=2, ) _PEP440_FALLBACK = re.compile(r"^v?(?P(?:[0-9]+!)?[0-9]+(?:\.[0-9]+)*)", re.I) class PEP440Warning(RuntimeWarning): """ Used when there is an issue with a version or specifier not complying with PEP 440. """ parse_version = packaging.version.Version _state_vars = {} def _declare_state(vartype, **kw): globals().update(kw) _state_vars.update(dict.fromkeys(kw, vartype)) def __getstate__(): state = {} g = globals() for k, v in _state_vars.items(): state[k] = g['_sget_' + v](g[k]) return state def __setstate__(state): g = globals() for k, v in state.items(): g['_sset_' + _state_vars[k]](k, g[k], v) return state def _sget_dict(val): return val.copy() def _sset_dict(key, ob, state): ob.clear() ob.update(state) def _sget_object(val): return val.__getstate__() def _sset_object(key, ob, state): ob.__setstate__(state) _sget_none = _sset_none = lambda *args: None def get_supported_platform(): """Return this platform's maximum compatible version. distutils.util.get_platform() normally reports the minimum version of macOS that would be required to *use* extensions produced by distutils. But what we want when checking compatibility is to know the version of macOS that we are *running*. To allow usage of packages that explicitly require a newer version of macOS, we must also know the current version of the OS. If this condition occurs for any other platform with a version in its platform strings, this function should be extended accordingly. """ plat = get_build_platform() m = macosVersionString.match(plat) if m is not None and sys.platform == "darwin": try: plat = 'macosx-%s-%s' % ('.'.join(_macos_vers()[:2]), m.group(3)) except ValueError: # not macOS pass return plat __all__ = [ # Basic resource access and distribution/entry point discovery 'require', 'run_script', 'get_provider', 'get_distribution', 'load_entry_point', 'get_entry_map', 'get_entry_info', 'iter_entry_points', 'resource_string', 'resource_stream', 'resource_filename', 'resource_listdir', 'resource_exists', 'resource_isdir', # Environmental control 'declare_namespace', 'working_set', 'add_activation_listener', 'find_distributions', 'set_extraction_path', 'cleanup_resources', 'get_default_cache', # Primary implementation classes 'Environment', 'WorkingSet', 'ResourceManager', 'Distribution', 'Requirement', 'EntryPoint', # Exceptions 'ResolutionError', 'VersionConflict', 'DistributionNotFound', 'UnknownExtra', 'ExtractionError', # Warnings 'PEP440Warning', # Parsing functions and string utilities 'parse_requirements', 'parse_version', 'safe_name', 'safe_version', 'get_platform', 'compatible_platforms', 'yield_lines', 'split_sections', 'safe_extra', 'to_filename', 'invalid_marker', 'evaluate_marker', # filesystem utilities 'ensure_directory', 'normalize_path', # Distribution "precedence" constants 'EGG_DIST', 'BINARY_DIST', 'SOURCE_DIST', 'CHECKOUT_DIST', 'DEVELOP_DIST', # "Provider" interfaces, implementations, and registration/lookup APIs 'IMetadataProvider', 'IResourceProvider', 'FileMetadata', 'PathMetadata', 'EggMetadata', 'EmptyProvider', 'empty_provider', 'NullProvider', 'EggProvider', 'DefaultProvider', 'ZipProvider', 'register_finder', 'register_namespace_handler', 'register_loader_type', 'fixup_namespace_packages', 'get_importer', # Warnings 'PkgResourcesDeprecationWarning', # Deprecated/backward compatibility only 'run_main', 'AvailableDistributions', ] class ResolutionError(Exception): """Abstract base for dependency resolution errors""" def __repr__(self): return self.__class__.__name__ + repr(self.args) class VersionConflict(ResolutionError): """ An already-installed version conflicts with the requested version. Should be initialized with the installed Distribution and the requested Requirement. """ _template = "{self.dist} is installed but {self.req} is required" @property def dist(self): return self.args[0] @property def req(self): return self.args[1] def report(self): return self._template.format(**locals()) def with_context(self, required_by): """ If required_by is non-empty, return a version of self that is a ContextualVersionConflict. """ if not required_by: return self args = self.args + (required_by,) return ContextualVersionConflict(*args) class ContextualVersionConflict(VersionConflict): """ A VersionConflict that accepts a third parameter, the set of the requirements that required the installed Distribution. """ _template = VersionConflict._template + ' by {self.required_by}' @property def required_by(self): return self.args[2] class DistributionNotFound(ResolutionError): """A requested distribution was not found""" _template = ( "The '{self.req}' distribution was not found " "and is required by {self.requirers_str}" ) @property def req(self): return self.args[0] @property def requirers(self): return self.args[1] @property def requirers_str(self): if not self.requirers: return 'the application' return ', '.join(self.requirers) def report(self): return self._template.format(**locals()) def __str__(self): return self.report() class UnknownExtra(ResolutionError): """Distribution doesn't have an "extra feature" of the given name""" _provider_factories = {} PY_MAJOR = '{}.{}'.format(*sys.version_info) EGG_DIST = 3 BINARY_DIST = 2 SOURCE_DIST = 1 CHECKOUT_DIST = 0 DEVELOP_DIST = -1 def register_loader_type(loader_type, provider_factory): """Register `provider_factory` to make providers for `loader_type` `loader_type` is the type or class of a PEP 302 ``module.__loader__``, and `provider_factory` is a function that, passed a *module* object, returns an ``IResourceProvider`` for that module. """ _provider_factories[loader_type] = provider_factory def get_provider(moduleOrReq): """Return an IResourceProvider for the named module or requirement""" if isinstance(moduleOrReq, Requirement): return working_set.find(moduleOrReq) or require(str(moduleOrReq))[0] try: module = sys.modules[moduleOrReq] except KeyError: __import__(moduleOrReq) module = sys.modules[moduleOrReq] loader = getattr(module, '__loader__', None) return _find_adapter(_provider_factories, loader)(module) def _macos_vers(_cache=[]): if not _cache: version = platform.mac_ver()[0] # fallback for MacPorts if version == '': plist = '/System/Library/CoreServices/SystemVersion.plist' if os.path.exists(plist): if hasattr(plistlib, 'readPlist'): plist_content = plistlib.readPlist(plist) if 'ProductVersion' in plist_content: version = plist_content['ProductVersion'] _cache.append(version.split('.')) return _cache[0] def _macos_arch(machine): return {'PowerPC': 'ppc', 'Power_Macintosh': 'ppc'}.get(machine, machine) def get_build_platform(): """Return this platform's string for platform-specific distributions XXX Currently this is the same as ``distutils.util.get_platform()``, but it needs some hacks for Linux and macOS. """ from sysconfig import get_platform plat = get_platform() if sys.platform == "darwin" and not plat.startswith('macosx-'): try: version = _macos_vers() machine = os.uname()[4].replace(" ", "_") return "macosx-%d.%d-%s" % ( int(version[0]), int(version[1]), _macos_arch(machine), ) except ValueError: # if someone is running a non-Mac darwin system, this will fall # through to the default implementation pass return plat macosVersionString = re.compile(r"macosx-(\d+)\.(\d+)-(.*)") darwinVersionString = re.compile(r"darwin-(\d+)\.(\d+)\.(\d+)-(.*)") # XXX backward compat get_platform = get_build_platform def compatible_platforms(provided, required): """Can code for the `provided` platform run on the `required` platform? Returns true if either platform is ``None``, or the platforms are equal. XXX Needs compatibility checks for Linux and other unixy OSes. """ if provided is None or required is None or provided == required: # easy case return True # macOS special cases reqMac = macosVersionString.match(required) if reqMac: provMac = macosVersionString.match(provided) # is this a Mac package? if not provMac: # this is backwards compatibility for packages built before # setuptools 0.6. All packages built after this point will # use the new macOS designation. provDarwin = darwinVersionString.match(provided) if provDarwin: dversion = int(provDarwin.group(1)) macosversion = "%s.%s" % (reqMac.group(1), reqMac.group(2)) if ( dversion == 7 and macosversion >= "10.3" or dversion == 8 and macosversion >= "10.4" ): return True # egg isn't macOS or legacy darwin return False # are they the same major version and machine type? if provMac.group(1) != reqMac.group(1) or provMac.group(3) != reqMac.group(3): return False # is the required OS major update >= the provided one? if int(provMac.group(2)) > int(reqMac.group(2)): return False return True # XXX Linux and other platforms' special cases should go here return False def run_script(dist_spec, script_name): """Locate distribution `dist_spec` and run its `script_name` script""" ns = sys._getframe(1).f_globals name = ns['__name__'] ns.clear() ns['__name__'] = name require(dist_spec)[0].run_script(script_name, ns) # backward compatibility run_main = run_script def get_distribution(dist): """Return a current distribution object for a Requirement or string""" if isinstance(dist, str): dist = Requirement.parse(dist) if isinstance(dist, Requirement): dist = get_provider(dist) if not isinstance(dist, Distribution): raise TypeError("Expected string, Requirement, or Distribution", dist) return dist def load_entry_point(dist, group, name): """Return `name` entry point of `group` for `dist` or raise ImportError""" return get_distribution(dist).load_entry_point(group, name) def get_entry_map(dist, group=None): """Return the entry point map for `group`, or the full entry map""" return get_distribution(dist).get_entry_map(group) def get_entry_info(dist, group, name): """Return the EntryPoint object for `group`+`name`, or ``None``""" return get_distribution(dist).get_entry_info(group, name) class IMetadataProvider: def has_metadata(name): """Does the package's distribution contain the named metadata?""" def get_metadata(name): """The named metadata resource as a string""" def get_metadata_lines(name): """Yield named metadata resource as list of non-blank non-comment lines Leading and trailing whitespace is stripped from each line, and lines with ``#`` as the first non-blank character are omitted.""" def metadata_isdir(name): """Is the named metadata a directory? (like ``os.path.isdir()``)""" def metadata_listdir(name): """List of metadata names in the directory (like ``os.listdir()``)""" def run_script(script_name, namespace): """Execute the named script in the supplied namespace dictionary""" class IResourceProvider(IMetadataProvider): """An object that provides access to package resources""" def get_resource_filename(manager, resource_name): """Return a true filesystem path for `resource_name` `manager` must be an ``IResourceManager``""" def get_resource_stream(manager, resource_name): """Return a readable file-like object for `resource_name` `manager` must be an ``IResourceManager``""" def get_resource_string(manager, resource_name): """Return a string containing the contents of `resource_name` `manager` must be an ``IResourceManager``""" def has_resource(resource_name): """Does the package contain the named resource?""" def resource_isdir(resource_name): """Is the named resource a directory? (like ``os.path.isdir()``)""" def resource_listdir(resource_name): """List of resource names in the directory (like ``os.listdir()``)""" class WorkingSet: """A collection of active distributions on sys.path (or a similar list)""" def __init__(self, entries=None): """Create working set from list of path entries (default=sys.path)""" self.entries = [] self.entry_keys = {} self.by_key = {} self.normalized_to_canonical_keys = {} self.callbacks = [] if entries is None: entries = sys.path for entry in entries: self.add_entry(entry) @classmethod def _build_master(cls): """ Prepare the master working set. """ ws = cls() try: from __main__ import __requires__ except ImportError: # The main program does not list any requirements return ws # ensure the requirements are met try: ws.require(__requires__) except VersionConflict: return cls._build_from_requirements(__requires__) return ws @classmethod def _build_from_requirements(cls, req_spec): """ Build a working set from a requirement spec. Rewrites sys.path. """ # try it without defaults already on sys.path # by starting with an empty path ws = cls([]) reqs = parse_requirements(req_spec) dists = ws.resolve(reqs, Environment()) for dist in dists: ws.add(dist) # add any missing entries from sys.path for entry in sys.path: if entry not in ws.entries: ws.add_entry(entry) # then copy back to sys.path sys.path[:] = ws.entries return ws def add_entry(self, entry): """Add a path item to ``.entries``, finding any distributions on it ``find_distributions(entry, True)`` is used to find distributions corresponding to the path entry, and they are added. `entry` is always appended to ``.entries``, even if it is already present. (This is because ``sys.path`` can contain the same value more than once, and the ``.entries`` of the ``sys.path`` WorkingSet should always equal ``sys.path``.) """ self.entry_keys.setdefault(entry, []) self.entries.append(entry) for dist in find_distributions(entry, True): self.add(dist, entry, False) def __contains__(self, dist): """True if `dist` is the active distribution for its project""" return self.by_key.get(dist.key) == dist def find(self, req): """Find a distribution matching requirement `req` If there is an active distribution for the requested project, this returns it as long as it meets the version requirement specified by `req`. But, if there is an active distribution for the project and it does *not* meet the `req` requirement, ``VersionConflict`` is raised. If there is no active distribution for the requested project, ``None`` is returned. """ dist = self.by_key.get(req.key) if dist is None: canonical_key = self.normalized_to_canonical_keys.get(req.key) if canonical_key is not None: req.key = canonical_key dist = self.by_key.get(canonical_key) if dist is not None and dist not in req: # XXX add more info raise VersionConflict(dist, req) return dist def iter_entry_points(self, group, name=None): """Yield entry point objects from `group` matching `name` If `name` is None, yields all entry points in `group` from all distributions in the working set, otherwise only ones matching both `group` and `name` are yielded (in distribution order). """ return ( entry for dist in self for entry in dist.get_entry_map(group).values() if name is None or name == entry.name ) def run_script(self, requires, script_name): """Locate distribution for `requires` and run `script_name` script""" ns = sys._getframe(1).f_globals name = ns['__name__'] ns.clear() ns['__name__'] = name self.require(requires)[0].run_script(script_name, ns) def __iter__(self): """Yield distributions for non-duplicate projects in the working set The yield order is the order in which the items' path entries were added to the working set. """ seen = {} for item in self.entries: if item not in self.entry_keys: # workaround a cache issue continue for key in self.entry_keys[item]: if key not in seen: seen[key] = 1 yield self.by_key[key] def add(self, dist, entry=None, insert=True, replace=False): """Add `dist` to working set, associated with `entry` If `entry` is unspecified, it defaults to the ``.location`` of `dist`. On exit from this routine, `entry` is added to the end of the working set's ``.entries`` (if it wasn't already present). `dist` is only added to the working set if it's for a project that doesn't already have a distribution in the set, unless `replace=True`. If it's added, any callbacks registered with the ``subscribe()`` method will be called. """ if insert: dist.insert_on(self.entries, entry, replace=replace) if entry is None: entry = dist.location keys = self.entry_keys.setdefault(entry, []) keys2 = self.entry_keys.setdefault(dist.location, []) if not replace and dist.key in self.by_key: # ignore hidden distros return self.by_key[dist.key] = dist normalized_name = packaging.utils.canonicalize_name(dist.key) self.normalized_to_canonical_keys[normalized_name] = dist.key if dist.key not in keys: keys.append(dist.key) if dist.key not in keys2: keys2.append(dist.key) self._added_new(dist) def resolve( self, requirements, env=None, installer=None, replace_conflicting=False, extras=None, ): """List all distributions needed to (recursively) meet `requirements` `requirements` must be a sequence of ``Requirement`` objects. `env`, if supplied, should be an ``Environment`` instance. If not supplied, it defaults to all distributions available within any entry or distribution in the working set. `installer`, if supplied, will be invoked with each requirement that cannot be met by an already-installed distribution; it should return a ``Distribution`` or ``None``. Unless `replace_conflicting=True`, raises a VersionConflict exception if any requirements are found on the path that have the correct name but the wrong version. Otherwise, if an `installer` is supplied it will be invoked to obtain the correct version of the requirement and activate it. `extras` is a list of the extras to be used with these requirements. This is important because extra requirements may look like `my_req; extra = "my_extra"`, which would otherwise be interpreted as a purely optional requirement. Instead, we want to be able to assert that these requirements are truly required. """ # set up the stack requirements = list(requirements)[::-1] # set of processed requirements processed = {} # key -> dist best = {} to_activate = [] req_extras = _ReqExtras() # Mapping of requirement to set of distributions that required it; # useful for reporting info about conflicts. required_by = collections.defaultdict(set) while requirements: # process dependencies breadth-first req = requirements.pop(0) if req in processed: # Ignore cyclic or redundant dependencies continue if not req_extras.markers_pass(req, extras): continue dist = self._resolve_dist( req, best, replace_conflicting, env, installer, required_by, to_activate ) # push the new requirements onto the stack new_requirements = dist.requires(req.extras)[::-1] requirements.extend(new_requirements) # Register the new requirements needed by req for new_requirement in new_requirements: required_by[new_requirement].add(req.project_name) req_extras[new_requirement] = req.extras processed[req] = True # return list of distros to activate return to_activate def _resolve_dist( self, req, best, replace_conflicting, env, installer, required_by, to_activate ): dist = best.get(req.key) if dist is None: # Find the best distribution and add it to the map dist = self.by_key.get(req.key) if dist is None or (dist not in req and replace_conflicting): ws = self if env is None: if dist is None: env = Environment(self.entries) else: # Use an empty environment and workingset to avoid # any further conflicts with the conflicting # distribution env = Environment([]) ws = WorkingSet([]) dist = best[req.key] = env.best_match( req, ws, installer, replace_conflicting=replace_conflicting ) if dist is None: requirers = required_by.get(req, None) raise DistributionNotFound(req, requirers) to_activate.append(dist) if dist not in req: # Oops, the "best" so far conflicts with a dependency dependent_req = required_by[req] raise VersionConflict(dist, req).with_context(dependent_req) return dist def find_plugins(self, plugin_env, full_env=None, installer=None, fallback=True): """Find all activatable distributions in `plugin_env` Example usage:: distributions, errors = working_set.find_plugins( Environment(plugin_dirlist) ) # add plugins+libs to sys.path map(working_set.add, distributions) # display errors print('Could not load', errors) The `plugin_env` should be an ``Environment`` instance that contains only distributions that are in the project's "plugin directory" or directories. The `full_env`, if supplied, should be an ``Environment`` contains all currently-available distributions. If `full_env` is not supplied, one is created automatically from the ``WorkingSet`` this method is called on, which will typically mean that every directory on ``sys.path`` will be scanned for distributions. `installer` is a standard installer callback as used by the ``resolve()`` method. The `fallback` flag indicates whether we should attempt to resolve older versions of a plugin if the newest version cannot be resolved. This method returns a 2-tuple: (`distributions`, `error_info`), where `distributions` is a list of the distributions found in `plugin_env` that were loadable, along with any other distributions that are needed to resolve their dependencies. `error_info` is a dictionary mapping unloadable plugin distributions to an exception instance describing the error that occurred. Usually this will be a ``DistributionNotFound`` or ``VersionConflict`` instance. """ plugin_projects = list(plugin_env) # scan project names in alphabetic order plugin_projects.sort() error_info = {} distributions = {} if full_env is None: env = Environment(self.entries) env += plugin_env else: env = full_env + plugin_env shadow_set = self.__class__([]) # put all our entries in shadow_set list(map(shadow_set.add, self)) for project_name in plugin_projects: for dist in plugin_env[project_name]: req = [dist.as_requirement()] try: resolvees = shadow_set.resolve(req, env, installer) except ResolutionError as v: # save error info error_info[dist] = v if fallback: # try the next older version of project continue else: # give up on this project, keep going break else: list(map(shadow_set.add, resolvees)) distributions.update(dict.fromkeys(resolvees)) # success, no need to try any more versions of this project break distributions = list(distributions) distributions.sort() return distributions, error_info def require(self, *requirements): """Ensure that distributions matching `requirements` are activated `requirements` must be a string or a (possibly-nested) sequence thereof, specifying the distributions and versions required. The return value is a sequence of the distributions that needed to be activated to fulfill the requirements; all relevant distributions are included, even if they were already activated in this working set. """ needed = self.resolve(parse_requirements(requirements)) for dist in needed: self.add(dist) return needed def subscribe(self, callback, existing=True): """Invoke `callback` for all distributions If `existing=True` (default), call on all existing ones, as well. """ if callback in self.callbacks: return self.callbacks.append(callback) if not existing: return for dist in self: callback(dist) def _added_new(self, dist): for callback in self.callbacks: callback(dist) def __getstate__(self): return ( self.entries[:], self.entry_keys.copy(), self.by_key.copy(), self.normalized_to_canonical_keys.copy(), self.callbacks[:], ) def __setstate__(self, e_k_b_n_c): entries, keys, by_key, normalized_to_canonical_keys, callbacks = e_k_b_n_c self.entries = entries[:] self.entry_keys = keys.copy() self.by_key = by_key.copy() self.normalized_to_canonical_keys = normalized_to_canonical_keys.copy() self.callbacks = callbacks[:] class _ReqExtras(dict): """ Map each requirement to the extras that demanded it. """ def markers_pass(self, req, extras=None): """ Evaluate markers for req against each extra that demanded it. Return False if the req has a marker and fails evaluation. Otherwise, return True. """ extra_evals = ( req.marker.evaluate({'extra': extra}) for extra in self.get(req, ()) + (extras or (None,)) ) return not req.marker or any(extra_evals) class Environment: """Searchable snapshot of distributions on a search path""" def __init__( self, search_path=None, platform=get_supported_platform(), python=PY_MAJOR ): """Snapshot distributions available on a search path Any distributions found on `search_path` are added to the environment. `search_path` should be a sequence of ``sys.path`` items. If not supplied, ``sys.path`` is used. `platform` is an optional string specifying the name of the platform that platform-specific distributions must be compatible with. If unspecified, it defaults to the current platform. `python` is an optional string naming the desired version of Python (e.g. ``'3.6'``); it defaults to the current version. You may explicitly set `platform` (and/or `python`) to ``None`` if you wish to map *all* distributions, not just those compatible with the running platform or Python version. """ self._distmap = {} self.platform = platform self.python = python self.scan(search_path) def can_add(self, dist): """Is distribution `dist` acceptable for this environment? The distribution must match the platform and python version requirements specified when this environment was created, or False is returned. """ py_compat = ( self.python is None or dist.py_version is None or dist.py_version == self.python ) return py_compat and compatible_platforms(dist.platform, self.platform) def remove(self, dist): """Remove `dist` from the environment""" self._distmap[dist.key].remove(dist) def scan(self, search_path=None): """Scan `search_path` for distributions usable in this environment Any distributions found are added to the environment. `search_path` should be a sequence of ``sys.path`` items. If not supplied, ``sys.path`` is used. Only distributions conforming to the platform/python version defined at initialization are added. """ if search_path is None: search_path = sys.path for item in search_path: for dist in find_distributions(item): self.add(dist) def __getitem__(self, project_name): """Return a newest-to-oldest list of distributions for `project_name` Uses case-insensitive `project_name` comparison, assuming all the project's distributions use their project's name converted to all lowercase as their key. """ distribution_key = project_name.lower() return self._distmap.get(distribution_key, []) def add(self, dist): """Add `dist` if we ``can_add()`` it and it has not already been added""" if self.can_add(dist) and dist.has_version(): dists = self._distmap.setdefault(dist.key, []) if dist not in dists: dists.append(dist) dists.sort(key=operator.attrgetter('hashcmp'), reverse=True) def best_match(self, req, working_set, installer=None, replace_conflicting=False): """Find distribution best matching `req` and usable on `working_set` This calls the ``find(req)`` method of the `working_set` to see if a suitable distribution is already active. (This may raise ``VersionConflict`` if an unsuitable version of the project is already active in the specified `working_set`.) If a suitable distribution isn't active, this method returns the newest distribution in the environment that meets the ``Requirement`` in `req`. If no suitable distribution is found, and `installer` is supplied, then the result of calling the environment's ``obtain(req, installer)`` method will be returned. """ try: dist = working_set.find(req) except VersionConflict: if not replace_conflicting: raise dist = None if dist is not None: return dist for dist in self[req.key]: if dist in req: return dist # try to download/install return self.obtain(req, installer) def obtain(self, requirement, installer=None): """Obtain a distribution matching `requirement` (e.g. via download) Obtain a distro that matches requirement (e.g. via download). In the base ``Environment`` class, this routine just returns ``installer(requirement)``, unless `installer` is None, in which case None is returned instead. This method is a hook that allows subclasses to attempt other ways of obtaining a distribution before falling back to the `installer` argument.""" if installer is not None: return installer(requirement) def __iter__(self): """Yield the unique project names of the available distributions""" for key in self._distmap.keys(): if self[key]: yield key def __iadd__(self, other): """In-place addition of a distribution or environment""" if isinstance(other, Distribution): self.add(other) elif isinstance(other, Environment): for project in other: for dist in other[project]: self.add(dist) else: raise TypeError("Can't add %r to environment" % (other,)) return self def __add__(self, other): """Add an environment or distribution to an environment""" new = self.__class__([], platform=None, python=None) for env in self, other: new += env return new # XXX backward compatibility AvailableDistributions = Environment class ExtractionError(RuntimeError): """An error occurred extracting a resource The following attributes are available from instances of this exception: manager The resource manager that raised this exception cache_path The base directory for resource extraction original_error The exception instance that caused extraction to fail """ class ResourceManager: """Manage resource extraction and packages""" extraction_path = None def __init__(self): self.cached_files = {} def resource_exists(self, package_or_requirement, resource_name): """Does the named resource exist?""" return get_provider(package_or_requirement).has_resource(resource_name) def resource_isdir(self, package_or_requirement, resource_name): """Is the named resource an existing directory?""" return get_provider(package_or_requirement).resource_isdir(resource_name) def resource_filename(self, package_or_requirement, resource_name): """Return a true filesystem path for specified resource""" return get_provider(package_or_requirement).get_resource_filename( self, resource_name ) def resource_stream(self, package_or_requirement, resource_name): """Return a readable file-like object for specified resource""" return get_provider(package_or_requirement).get_resource_stream( self, resource_name ) def resource_string(self, package_or_requirement, resource_name): """Return specified resource as a string""" return get_provider(package_or_requirement).get_resource_string( self, resource_name ) def resource_listdir(self, package_or_requirement, resource_name): """List the contents of the named resource directory""" return get_provider(package_or_requirement).resource_listdir(resource_name) def extraction_error(self): """Give an error message for problems extracting file(s)""" old_exc = sys.exc_info()[1] cache_path = self.extraction_path or get_default_cache() tmpl = textwrap.dedent( """ Can't extract file(s) to egg cache The following error occurred while trying to extract file(s) to the Python egg cache: {old_exc} The Python egg cache directory is currently set to: {cache_path} Perhaps your account does not have write access to this directory? You can change the cache directory by setting the PYTHON_EGG_CACHE environment variable to point to an accessible directory. """ ).lstrip() err = ExtractionError(tmpl.format(**locals())) err.manager = self err.cache_path = cache_path err.original_error = old_exc raise err def get_cache_path(self, archive_name, names=()): """Return absolute location in cache for `archive_name` and `names` The parent directory of the resulting path will be created if it does not already exist. `archive_name` should be the base filename of the enclosing egg (which may not be the name of the enclosing zipfile!), including its ".egg" extension. `names`, if provided, should be a sequence of path name parts "under" the egg's extraction location. This method should only be called by resource providers that need to obtain an extraction location, and only for names they intend to extract, as it tracks the generated names for possible cleanup later. """ extract_path = self.extraction_path or get_default_cache() target_path = os.path.join(extract_path, archive_name + '-tmp', *names) try: _bypass_ensure_directory(target_path) except Exception: self.extraction_error() self._warn_unsafe_extraction_path(extract_path) self.cached_files[target_path] = 1 return target_path @staticmethod def _warn_unsafe_extraction_path(path): """ If the default extraction path is overridden and set to an insecure location, such as /tmp, it opens up an opportunity for an attacker to replace an extracted file with an unauthorized payload. Warn the user if a known insecure location is used. See Distribute #375 for more details. """ if os.name == 'nt' and not path.startswith(os.environ['windir']): # On Windows, permissions are generally restrictive by default # and temp directories are not writable by other users, so # bypass the warning. return mode = os.stat(path).st_mode if mode & stat.S_IWOTH or mode & stat.S_IWGRP: msg = ( "Extraction path is writable by group/others " "and vulnerable to attack when " "used with get_resource_filename ({path}). " "Consider a more secure " "location (set with .set_extraction_path or the " "PYTHON_EGG_CACHE environment variable)." ).format(**locals()) warnings.warn(msg, UserWarning) def postprocess(self, tempname, filename): """Perform any platform-specific postprocessing of `tempname` This is where Mac header rewrites should be done; other platforms don't have anything special they should do. Resource providers should call this method ONLY after successfully extracting a compressed resource. They must NOT call it on resources that are already in the filesystem. `tempname` is the current (temporary) name of the file, and `filename` is the name it will be renamed to by the caller after this routine returns. """ if os.name == 'posix': # Make the resource executable mode = ((os.stat(tempname).st_mode) | 0o555) & 0o7777 os.chmod(tempname, mode) def set_extraction_path(self, path): """Set the base path where resources will be extracted to, if needed. If you do not call this routine before any extractions take place, the path defaults to the return value of ``get_default_cache()``. (Which is based on the ``PYTHON_EGG_CACHE`` environment variable, with various platform-specific fallbacks. See that routine's documentation for more details.) Resources are extracted to subdirectories of this path based upon information given by the ``IResourceProvider``. You may set this to a temporary directory, but then you must call ``cleanup_resources()`` to delete the extracted files when done. There is no guarantee that ``cleanup_resources()`` will be able to remove all extracted files. (Note: you may not change the extraction path for a given resource manager once resources have been extracted, unless you first call ``cleanup_resources()``.) """ if self.cached_files: raise ValueError("Can't change extraction path, files already extracted") self.extraction_path = path def cleanup_resources(self, force=False): """ Delete all extracted resource files and directories, returning a list of the file and directory names that could not be successfully removed. This function does not have any concurrency protection, so it should generally only be called when the extraction path is a temporary directory exclusive to a single process. This method is not automatically called; you must call it explicitly or register it as an ``atexit`` function if you wish to ensure cleanup of a temporary directory used for extractions. """ # XXX def get_default_cache(): """ Return the ``PYTHON_EGG_CACHE`` environment variable or a platform-relevant user cache dir for an app named "Python-Eggs". """ return os.environ.get('PYTHON_EGG_CACHE') or platformdirs.user_cache_dir( appname='Python-Eggs' ) def safe_name(name): """Convert an arbitrary string to a standard distribution name Any runs of non-alphanumeric/. characters are replaced with a single '-'. """ return re.sub('[^A-Za-z0-9.]+', '-', name) def safe_version(version): """ Convert an arbitrary string to a standard version string """ try: # normalize the version return str(packaging.version.Version(version)) except packaging.version.InvalidVersion: version = version.replace(' ', '.') return re.sub('[^A-Za-z0-9.]+', '-', version) def _forgiving_version(version): """Fallback when ``safe_version`` is not safe enough >>> parse_version(_forgiving_version('0.23ubuntu1')) >>> parse_version(_forgiving_version('0.23-')) >>> parse_version(_forgiving_version('0.-_')) >>> parse_version(_forgiving_version('42.+?1')) >>> parse_version(_forgiving_version('hello world')) """ version = version.replace(' ', '.') match = _PEP440_FALLBACK.search(version) if match: safe = match["safe"] rest = version[len(safe) :] else: safe = "0" rest = version local = f"sanitized.{_safe_segment(rest)}".strip(".") return f"{safe}.dev0+{local}" def _safe_segment(segment): """Convert an arbitrary string into a safe segment""" segment = re.sub('[^A-Za-z0-9.]+', '-', segment) segment = re.sub('-[^A-Za-z0-9]+', '-', segment) return re.sub(r'\.[^A-Za-z0-9]+', '.', segment).strip(".-") def safe_extra(extra): """Convert an arbitrary string to a standard 'extra' name Any runs of non-alphanumeric characters are replaced with a single '_', and the result is always lowercased. """ return re.sub('[^A-Za-z0-9.-]+', '_', extra).lower() def to_filename(name): """Convert a project or version name to its filename-escaped form Any '-' characters are currently replaced with '_'. """ return name.replace('-', '_') def invalid_marker(text): """ Validate text as a PEP 508 environment marker; return an exception if invalid or False otherwise. """ try: evaluate_marker(text) except SyntaxError as e: e.filename = None e.lineno = None return e return False def evaluate_marker(text, extra=None): """ Evaluate a PEP 508 environment marker. Return a boolean indicating the marker result in this environment. Raise SyntaxError if marker is invalid. This implementation uses the 'pyparsing' module. """ try: marker = packaging.markers.Marker(text) return marker.evaluate() except packaging.markers.InvalidMarker as e: raise SyntaxError(e) from e class NullProvider: """Try to implement resources and metadata for arbitrary PEP 302 loaders""" egg_name = None egg_info = None loader = None def __init__(self, module): self.loader = getattr(module, '__loader__', None) self.module_path = os.path.dirname(getattr(module, '__file__', '')) def get_resource_filename(self, manager, resource_name): return self._fn(self.module_path, resource_name) def get_resource_stream(self, manager, resource_name): return io.BytesIO(self.get_resource_string(manager, resource_name)) def get_resource_string(self, manager, resource_name): return self._get(self._fn(self.module_path, resource_name)) def has_resource(self, resource_name): return self._has(self._fn(self.module_path, resource_name)) def _get_metadata_path(self, name): return self._fn(self.egg_info, name) def has_metadata(self, name): if not self.egg_info: return self.egg_info path = self._get_metadata_path(name) return self._has(path) def get_metadata(self, name): if not self.egg_info: return "" path = self._get_metadata_path(name) value = self._get(path) try: return value.decode('utf-8') except UnicodeDecodeError as exc: # Include the path in the error message to simplify # troubleshooting, and without changing the exception type. exc.reason += ' in {} file at path: {}'.format(name, path) raise def get_metadata_lines(self, name): return yield_lines(self.get_metadata(name)) def resource_isdir(self, resource_name): return self._isdir(self._fn(self.module_path, resource_name)) def metadata_isdir(self, name): return self.egg_info and self._isdir(self._fn(self.egg_info, name)) def resource_listdir(self, resource_name): return self._listdir(self._fn(self.module_path, resource_name)) def metadata_listdir(self, name): if self.egg_info: return self._listdir(self._fn(self.egg_info, name)) return [] def run_script(self, script_name, namespace): script = 'scripts/' + script_name if not self.has_metadata(script): raise ResolutionError( "Script {script!r} not found in metadata at {self.egg_info!r}".format( **locals() ), ) script_text = self.get_metadata(script).replace('\r\n', '\n') script_text = script_text.replace('\r', '\n') script_filename = self._fn(self.egg_info, script) namespace['__file__'] = script_filename if os.path.exists(script_filename): with open(script_filename) as fid: source = fid.read() code = compile(source, script_filename, 'exec') exec(code, namespace, namespace) else: from linecache import cache cache[script_filename] = ( len(script_text), 0, script_text.split('\n'), script_filename, ) script_code = compile(script_text, script_filename, 'exec') exec(script_code, namespace, namespace) def _has(self, path): raise NotImplementedError( "Can't perform this operation for unregistered loader type" ) def _isdir(self, path): raise NotImplementedError( "Can't perform this operation for unregistered loader type" ) def _listdir(self, path): raise NotImplementedError( "Can't perform this operation for unregistered loader type" ) def _fn(self, base, resource_name): self._validate_resource_path(resource_name) if resource_name: return os.path.join(base, *resource_name.split('/')) return base @staticmethod def _validate_resource_path(path): """ Validate the resource paths according to the docs. https://setuptools.pypa.io/en/latest/pkg_resources.html#basic-resource-access >>> warned = getfixture('recwarn') >>> warnings.simplefilter('always') >>> vrp = NullProvider._validate_resource_path >>> vrp('foo/bar.txt') >>> bool(warned) False >>> vrp('../foo/bar.txt') >>> bool(warned) True >>> warned.clear() >>> vrp('/foo/bar.txt') >>> bool(warned) True >>> vrp('foo/../../bar.txt') >>> bool(warned) True >>> warned.clear() >>> vrp('foo/f../bar.txt') >>> bool(warned) False Windows path separators are straight-up disallowed. >>> vrp(r'\\foo/bar.txt') Traceback (most recent call last): ... ValueError: Use of .. or absolute path in a resource path \ is not allowed. >>> vrp(r'C:\\foo/bar.txt') Traceback (most recent call last): ... ValueError: Use of .. or absolute path in a resource path \ is not allowed. Blank values are allowed >>> vrp('') >>> bool(warned) False Non-string values are not. >>> vrp(None) Traceback (most recent call last): ... AttributeError: ... """ invalid = ( os.path.pardir in path.split(posixpath.sep) or posixpath.isabs(path) or ntpath.isabs(path) ) if not invalid: return msg = "Use of .. or absolute path in a resource path is not allowed." # Aggressively disallow Windows absolute paths if ntpath.isabs(path) and not posixpath.isabs(path): raise ValueError(msg) # for compatibility, warn; in future # raise ValueError(msg) issue_warning( msg[:-1] + " and will raise exceptions in a future release.", DeprecationWarning, ) def _get(self, path): if hasattr(self.loader, 'get_data'): return self.loader.get_data(path) raise NotImplementedError( "Can't perform this operation for loaders without 'get_data()'" ) register_loader_type(object, NullProvider) def _parents(path): """ yield all parents of path including path """ last = None while path != last: yield path last = path path, _ = os.path.split(path) class EggProvider(NullProvider): """Provider based on a virtual filesystem""" def __init__(self, module): super().__init__(module) self._setup_prefix() def _setup_prefix(self): # Assume that metadata may be nested inside a "basket" # of multiple eggs and use module_path instead of .archive. eggs = filter(_is_egg_path, _parents(self.module_path)) egg = next(eggs, None) egg and self._set_egg(egg) def _set_egg(self, path): self.egg_name = os.path.basename(path) self.egg_info = os.path.join(path, 'EGG-INFO') self.egg_root = path class DefaultProvider(EggProvider): """Provides access to package resources in the filesystem""" def _has(self, path): return os.path.exists(path) def _isdir(self, path): return os.path.isdir(path) def _listdir(self, path): return os.listdir(path) def get_resource_stream(self, manager, resource_name): return open(self._fn(self.module_path, resource_name), 'rb') def _get(self, path): with open(path, 'rb') as stream: return stream.read() @classmethod def _register(cls): loader_names = ( 'SourceFileLoader', 'SourcelessFileLoader', ) for name in loader_names: loader_cls = getattr(importlib_machinery, name, type(None)) register_loader_type(loader_cls, cls) DefaultProvider._register() class EmptyProvider(NullProvider): """Provider that returns nothing for all requests""" module_path = None _isdir = _has = lambda self, path: False def _get(self, path): return '' def _listdir(self, path): return [] def __init__(self): pass empty_provider = EmptyProvider() class ZipManifests(dict): """ zip manifest builder """ @classmethod def build(cls, path): """ Build a dictionary similar to the zipimport directory caches, except instead of tuples, store ZipInfo objects. Use a platform-specific path separator (os.sep) for the path keys for compatibility with pypy on Windows. """ with zipfile.ZipFile(path) as zfile: items = ( ( name.replace('/', os.sep), zfile.getinfo(name), ) for name in zfile.namelist() ) return dict(items) load = build class MemoizedZipManifests(ZipManifests): """ Memoized zipfile manifests. """ manifest_mod = collections.namedtuple('manifest_mod', 'manifest mtime') def load(self, path): """ Load a manifest at path or return a suitable manifest already loaded. """ path = os.path.normpath(path) mtime = os.stat(path).st_mtime if path not in self or self[path].mtime != mtime: manifest = self.build(path) self[path] = self.manifest_mod(manifest, mtime) return self[path].manifest class ZipProvider(EggProvider): """Resource support for zips and eggs""" eagers = None _zip_manifests = MemoizedZipManifests() def __init__(self, module): super().__init__(module) self.zip_pre = self.loader.archive + os.sep def _zipinfo_name(self, fspath): # Convert a virtual filename (full path to file) into a zipfile subpath # usable with the zipimport directory cache for our target archive fspath = fspath.rstrip(os.sep) if fspath == self.loader.archive: return '' if fspath.startswith(self.zip_pre): return fspath[len(self.zip_pre) :] raise AssertionError("%s is not a subpath of %s" % (fspath, self.zip_pre)) def _parts(self, zip_path): # Convert a zipfile subpath into an egg-relative path part list. # pseudo-fs path fspath = self.zip_pre + zip_path if fspath.startswith(self.egg_root + os.sep): return fspath[len(self.egg_root) + 1 :].split(os.sep) raise AssertionError("%s is not a subpath of %s" % (fspath, self.egg_root)) @property def zipinfo(self): return self._zip_manifests.load(self.loader.archive) def get_resource_filename(self, manager, resource_name): if not self.egg_name: raise NotImplementedError( "resource_filename() only supported for .egg, not .zip" ) # no need to lock for extraction, since we use temp names zip_path = self._resource_to_zip(resource_name) eagers = self._get_eager_resources() if '/'.join(self._parts(zip_path)) in eagers: for name in eagers: self._extract_resource(manager, self._eager_to_zip(name)) return self._extract_resource(manager, zip_path) @staticmethod def _get_date_and_size(zip_stat): size = zip_stat.file_size # ymdhms+wday, yday, dst date_time = zip_stat.date_time + (0, 0, -1) # 1980 offset already done timestamp = time.mktime(date_time) return timestamp, size # FIXME: 'ZipProvider._extract_resource' is too complex (12) def _extract_resource(self, manager, zip_path): # noqa: C901 if zip_path in self._index(): for name in self._index()[zip_path]: last = self._extract_resource(manager, os.path.join(zip_path, name)) # return the extracted directory name return os.path.dirname(last) timestamp, size = self._get_date_and_size(self.zipinfo[zip_path]) if not WRITE_SUPPORT: raise IOError( '"os.rename" and "os.unlink" are not supported ' 'on this platform' ) try: real_path = manager.get_cache_path(self.egg_name, self._parts(zip_path)) if self._is_current(real_path, zip_path): return real_path outf, tmpnam = _mkstemp( ".$extract", dir=os.path.dirname(real_path), ) os.write(outf, self.loader.get_data(zip_path)) os.close(outf) utime(tmpnam, (timestamp, timestamp)) manager.postprocess(tmpnam, real_path) try: rename(tmpnam, real_path) except os.error: if os.path.isfile(real_path): if self._is_current(real_path, zip_path): # the file became current since it was checked above, # so proceed. return real_path # Windows, del old file and retry elif os.name == 'nt': unlink(real_path) rename(tmpnam, real_path) return real_path raise except os.error: # report a user-friendly error manager.extraction_error() return real_path def _is_current(self, file_path, zip_path): """ Return True if the file_path is current for this zip_path """ timestamp, size = self._get_date_and_size(self.zipinfo[zip_path]) if not os.path.isfile(file_path): return False stat = os.stat(file_path) if stat.st_size != size or stat.st_mtime != timestamp: return False # check that the contents match zip_contents = self.loader.get_data(zip_path) with open(file_path, 'rb') as f: file_contents = f.read() return zip_contents == file_contents def _get_eager_resources(self): if self.eagers is None: eagers = [] for name in ('native_libs.txt', 'eager_resources.txt'): if self.has_metadata(name): eagers.extend(self.get_metadata_lines(name)) self.eagers = eagers return self.eagers def _index(self): try: return self._dirindex except AttributeError: ind = {} for path in self.zipinfo: parts = path.split(os.sep) while parts: parent = os.sep.join(parts[:-1]) if parent in ind: ind[parent].append(parts[-1]) break else: ind[parent] = [parts.pop()] self._dirindex = ind return ind def _has(self, fspath): zip_path = self._zipinfo_name(fspath) return zip_path in self.zipinfo or zip_path in self._index() def _isdir(self, fspath): return self._zipinfo_name(fspath) in self._index() def _listdir(self, fspath): return list(self._index().get(self._zipinfo_name(fspath), ())) def _eager_to_zip(self, resource_name): return self._zipinfo_name(self._fn(self.egg_root, resource_name)) def _resource_to_zip(self, resource_name): return self._zipinfo_name(self._fn(self.module_path, resource_name)) register_loader_type(zipimport.zipimporter, ZipProvider) class FileMetadata(EmptyProvider): """Metadata handler for standalone PKG-INFO files Usage:: metadata = FileMetadata("/path/to/PKG-INFO") This provider rejects all data and metadata requests except for PKG-INFO, which is treated as existing, and will be the contents of the file at the provided location. """ def __init__(self, path): self.path = path def _get_metadata_path(self, name): return self.path def has_metadata(self, name): return name == 'PKG-INFO' and os.path.isfile(self.path) def get_metadata(self, name): if name != 'PKG-INFO': raise KeyError("No metadata except PKG-INFO is available") with io.open(self.path, encoding='utf-8', errors="replace") as f: metadata = f.read() self._warn_on_replacement(metadata) return metadata def _warn_on_replacement(self, metadata): replacement_char = '�' if replacement_char in metadata: tmpl = "{self.path} could not be properly decoded in UTF-8" msg = tmpl.format(**locals()) warnings.warn(msg) def get_metadata_lines(self, name): return yield_lines(self.get_metadata(name)) class PathMetadata(DefaultProvider): """Metadata provider for egg directories Usage:: # Development eggs: egg_info = "/path/to/PackageName.egg-info" base_dir = os.path.dirname(egg_info) metadata = PathMetadata(base_dir, egg_info) dist_name = os.path.splitext(os.path.basename(egg_info))[0] dist = Distribution(basedir, project_name=dist_name, metadata=metadata) # Unpacked egg directories: egg_path = "/path/to/PackageName-ver-pyver-etc.egg" metadata = PathMetadata(egg_path, os.path.join(egg_path,'EGG-INFO')) dist = Distribution.from_filename(egg_path, metadata=metadata) """ def __init__(self, path, egg_info): self.module_path = path self.egg_info = egg_info class EggMetadata(ZipProvider): """Metadata provider for .egg files""" def __init__(self, importer): """Create a metadata provider from a zipimporter""" self.zip_pre = importer.archive + os.sep self.loader = importer if importer.prefix: self.module_path = os.path.join(importer.archive, importer.prefix) else: self.module_path = importer.archive self._setup_prefix() _declare_state('dict', _distribution_finders={}) def register_finder(importer_type, distribution_finder): """Register `distribution_finder` to find distributions in sys.path items `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item handler), and `distribution_finder` is a callable that, passed a path item and the importer instance, yields ``Distribution`` instances found on that path item. See ``pkg_resources.find_on_path`` for an example.""" _distribution_finders[importer_type] = distribution_finder def find_distributions(path_item, only=False): """Yield distributions accessible via `path_item`""" importer = get_importer(path_item) finder = _find_adapter(_distribution_finders, importer) return finder(importer, path_item, only) def find_eggs_in_zip(importer, path_item, only=False): """ Find eggs in zip files; possibly multiple nested eggs. """ if importer.archive.endswith('.whl'): # wheels are not supported with this finder # they don't have PKG-INFO metadata, and won't ever contain eggs return metadata = EggMetadata(importer) if metadata.has_metadata('PKG-INFO'): yield Distribution.from_filename(path_item, metadata=metadata) if only: # don't yield nested distros return for subitem in metadata.resource_listdir(''): if _is_egg_path(subitem): subpath = os.path.join(path_item, subitem) dists = find_eggs_in_zip(zipimport.zipimporter(subpath), subpath) for dist in dists: yield dist elif subitem.lower().endswith(('.dist-info', '.egg-info')): subpath = os.path.join(path_item, subitem) submeta = EggMetadata(zipimport.zipimporter(subpath)) submeta.egg_info = subpath yield Distribution.from_location(path_item, subitem, submeta) register_finder(zipimport.zipimporter, find_eggs_in_zip) def find_nothing(importer, path_item, only=False): return () register_finder(object, find_nothing) def find_on_path(importer, path_item, only=False): """Yield distributions accessible on a sys.path directory""" path_item = _normalize_cached(path_item) if _is_unpacked_egg(path_item): yield Distribution.from_filename( path_item, metadata=PathMetadata(path_item, os.path.join(path_item, 'EGG-INFO')), ) return entries = (os.path.join(path_item, child) for child in safe_listdir(path_item)) # scan for .egg and .egg-info in directory for entry in sorted(entries): fullpath = os.path.join(path_item, entry) factory = dist_factory(path_item, entry, only) for dist in factory(fullpath): yield dist def dist_factory(path_item, entry, only): """Return a dist_factory for the given entry.""" lower = entry.lower() is_egg_info = lower.endswith('.egg-info') is_dist_info = lower.endswith('.dist-info') and os.path.isdir( os.path.join(path_item, entry) ) is_meta = is_egg_info or is_dist_info return ( distributions_from_metadata if is_meta else find_distributions if not only and _is_egg_path(entry) else resolve_egg_link if not only and lower.endswith('.egg-link') else NoDists() ) class NoDists: """ >>> bool(NoDists()) False >>> list(NoDists()('anything')) [] """ def __bool__(self): return False def __call__(self, fullpath): return iter(()) def safe_listdir(path): """ Attempt to list contents of path, but suppress some exceptions. """ try: return os.listdir(path) except (PermissionError, NotADirectoryError): pass except OSError as e: # Ignore the directory if does not exist, not a directory or # permission denied if e.errno not in (errno.ENOTDIR, errno.EACCES, errno.ENOENT): raise return () def distributions_from_metadata(path): root = os.path.dirname(path) if os.path.isdir(path): if len(os.listdir(path)) == 0: # empty metadata dir; skip return metadata = PathMetadata(root, path) else: metadata = FileMetadata(path) entry = os.path.basename(path) yield Distribution.from_location( root, entry, metadata, precedence=DEVELOP_DIST, ) def non_empty_lines(path): """ Yield non-empty lines from file at path """ with open(path) as f: for line in f: line = line.strip() if line: yield line def resolve_egg_link(path): """ Given a path to an .egg-link, resolve distributions present in the referenced path. """ referenced_paths = non_empty_lines(path) resolved_paths = ( os.path.join(os.path.dirname(path), ref) for ref in referenced_paths ) dist_groups = map(find_distributions, resolved_paths) return next(dist_groups, ()) if hasattr(pkgutil, 'ImpImporter'): register_finder(pkgutil.ImpImporter, find_on_path) register_finder(importlib_machinery.FileFinder, find_on_path) _declare_state('dict', _namespace_handlers={}) _declare_state('dict', _namespace_packages={}) def register_namespace_handler(importer_type, namespace_handler): """Register `namespace_handler` to declare namespace packages `importer_type` is the type or class of a PEP 302 "Importer" (sys.path item handler), and `namespace_handler` is a callable like this:: def namespace_handler(importer, path_entry, moduleName, module): # return a path_entry to use for child packages Namespace handlers are only called if the importer object has already agreed that it can handle the relevant path item, and they should only return a subpath if the module __path__ does not already contain an equivalent subpath. For an example namespace handler, see ``pkg_resources.file_ns_handler``. """ _namespace_handlers[importer_type] = namespace_handler def _handle_ns(packageName, path_item): """Ensure that named package includes a subpath of path_item (if needed)""" importer = get_importer(path_item) if importer is None: return None # use find_spec (PEP 451) and fall-back to find_module (PEP 302) try: spec = importer.find_spec(packageName) except AttributeError: # capture warnings due to #1111 with warnings.catch_warnings(): warnings.simplefilter("ignore") loader = importer.find_module(packageName) else: loader = spec.loader if spec else None if loader is None: return None module = sys.modules.get(packageName) if module is None: module = sys.modules[packageName] = types.ModuleType(packageName) module.__path__ = [] _set_parent_ns(packageName) elif not hasattr(module, '__path__'): raise TypeError("Not a package:", packageName) handler = _find_adapter(_namespace_handlers, importer) subpath = handler(importer, path_item, packageName, module) if subpath is not None: path = module.__path__ path.append(subpath) importlib.import_module(packageName) _rebuild_mod_path(path, packageName, module) return subpath def _rebuild_mod_path(orig_path, package_name, module): """ Rebuild module.__path__ ensuring that all entries are ordered corresponding to their sys.path order """ sys_path = [_normalize_cached(p) for p in sys.path] def safe_sys_path_index(entry): """ Workaround for #520 and #513. """ try: return sys_path.index(entry) except ValueError: return float('inf') def position_in_sys_path(path): """ Return the ordinal of the path based on its position in sys.path """ path_parts = path.split(os.sep) module_parts = package_name.count('.') + 1 parts = path_parts[:-module_parts] return safe_sys_path_index(_normalize_cached(os.sep.join(parts))) new_path = sorted(orig_path, key=position_in_sys_path) new_path = [_normalize_cached(p) for p in new_path] if isinstance(module.__path__, list): module.__path__[:] = new_path else: module.__path__ = new_path def declare_namespace(packageName): """Declare that package 'packageName' is a namespace package""" msg = ( f"Deprecated call to `pkg_resources.declare_namespace({packageName!r})`.\n" "Implementing implicit namespace packages (as specified in PEP 420) " "is preferred to `pkg_resources.declare_namespace`. " "See https://setuptools.pypa.io/en/latest/references/" "keywords.html#keyword-namespace-packages" ) warnings.warn(msg, DeprecationWarning, stacklevel=2) _imp.acquire_lock() try: if packageName in _namespace_packages: return path = sys.path parent, _, _ = packageName.rpartition('.') if parent: declare_namespace(parent) if parent not in _namespace_packages: __import__(parent) try: path = sys.modules[parent].__path__ except AttributeError as e: raise TypeError("Not a package:", parent) from e # Track what packages are namespaces, so when new path items are added, # they can be updated _namespace_packages.setdefault(parent or None, []).append(packageName) _namespace_packages.setdefault(packageName, []) for path_item in path: # Ensure all the parent's path items are reflected in the child, # if they apply _handle_ns(packageName, path_item) finally: _imp.release_lock() def fixup_namespace_packages(path_item, parent=None): """Ensure that previously-declared namespace packages include path_item""" _imp.acquire_lock() try: for package in _namespace_packages.get(parent, ()): subpath = _handle_ns(package, path_item) if subpath: fixup_namespace_packages(subpath, package) finally: _imp.release_lock() def file_ns_handler(importer, path_item, packageName, module): """Compute an ns-package subpath for a filesystem or zipfile importer""" subpath = os.path.join(path_item, packageName.split('.')[-1]) normalized = _normalize_cached(subpath) for item in module.__path__: if _normalize_cached(item) == normalized: break else: # Only return the path if it's not already there return subpath if hasattr(pkgutil, 'ImpImporter'): register_namespace_handler(pkgutil.ImpImporter, file_ns_handler) register_namespace_handler(zipimport.zipimporter, file_ns_handler) register_namespace_handler(importlib_machinery.FileFinder, file_ns_handler) def null_ns_handler(importer, path_item, packageName, module): return None register_namespace_handler(object, null_ns_handler) def normalize_path(filename): """Normalize a file/dir name for comparison purposes""" return os.path.normcase(os.path.realpath(os.path.normpath(_cygwin_patch(filename)))) def _cygwin_patch(filename): # pragma: nocover """ Contrary to POSIX 2008, on Cygwin, getcwd (3) contains symlink components. Using os.path.abspath() works around this limitation. A fix in os.getcwd() would probably better, in Cygwin even more so, except that this seems to be by design... """ return os.path.abspath(filename) if sys.platform == 'cygwin' else filename def _normalize_cached(filename, _cache={}): try: return _cache[filename] except KeyError: _cache[filename] = result = normalize_path(filename) return result def _is_egg_path(path): """ Determine if given path appears to be an egg. """ return _is_zip_egg(path) or _is_unpacked_egg(path) def _is_zip_egg(path): return ( path.lower().endswith('.egg') and os.path.isfile(path) and zipfile.is_zipfile(path) ) def _is_unpacked_egg(path): """ Determine if given path appears to be an unpacked egg. """ return path.lower().endswith('.egg') and os.path.isfile( os.path.join(path, 'EGG-INFO', 'PKG-INFO') ) def _set_parent_ns(packageName): parts = packageName.split('.') name = parts.pop() if parts: parent = '.'.join(parts) setattr(sys.modules[parent], name, sys.modules[packageName]) MODULE = re.compile(r"\w+(\.\w+)*$").match EGG_NAME = re.compile( r""" (?P[^-]+) ( -(?P[^-]+) ( -py(?P[^-]+) ( -(?P.+) )? )? )? """, re.VERBOSE | re.IGNORECASE, ).match class EntryPoint: """Object representing an advertised importable object""" def __init__(self, name, module_name, attrs=(), extras=(), dist=None): if not MODULE(module_name): raise ValueError("Invalid module name", module_name) self.name = name self.module_name = module_name self.attrs = tuple(attrs) self.extras = tuple(extras) self.dist = dist def __str__(self): s = "%s = %s" % (self.name, self.module_name) if self.attrs: s += ':' + '.'.join(self.attrs) if self.extras: s += ' [%s]' % ','.join(self.extras) return s def __repr__(self): return "EntryPoint.parse(%r)" % str(self) def load(self, require=True, *args, **kwargs): """ Require packages for this EntryPoint, then resolve it. """ if not require or args or kwargs: warnings.warn( "Parameters to load are deprecated. Call .resolve and " ".require separately.", PkgResourcesDeprecationWarning, stacklevel=2, ) if require: self.require(*args, **kwargs) return self.resolve() def resolve(self): """ Resolve the entry point from its module and attrs. """ module = __import__(self.module_name, fromlist=['__name__'], level=0) try: return functools.reduce(getattr, self.attrs, module) except AttributeError as exc: raise ImportError(str(exc)) from exc def require(self, env=None, installer=None): if self.extras and not self.dist: raise UnknownExtra("Can't require() without a distribution", self) # Get the requirements for this entry point with all its extras and # then resolve them. We have to pass `extras` along when resolving so # that the working set knows what extras we want. Otherwise, for # dist-info distributions, the working set will assume that the # requirements for that extra are purely optional and skip over them. reqs = self.dist.requires(self.extras) items = working_set.resolve(reqs, env, installer, extras=self.extras) list(map(working_set.add, items)) pattern = re.compile( r'\s*' r'(?P.+?)\s*' r'=\s*' r'(?P[\w.]+)\s*' r'(:\s*(?P[\w.]+))?\s*' r'(?P\[.*\])?\s*$' ) @classmethod def parse(cls, src, dist=None): """Parse a single entry point from string `src` Entry point syntax follows the form:: name = some.module:some.attr [extra1, extra2] The entry name and module name are required, but the ``:attrs`` and ``[extras]`` parts are optional """ m = cls.pattern.match(src) if not m: msg = "EntryPoint must be in 'name=module:attrs [extras]' format" raise ValueError(msg, src) res = m.groupdict() extras = cls._parse_extras(res['extras']) attrs = res['attr'].split('.') if res['attr'] else () return cls(res['name'], res['module'], attrs, extras, dist) @classmethod def _parse_extras(cls, extras_spec): if not extras_spec: return () req = Requirement.parse('x' + extras_spec) if req.specs: raise ValueError() return req.extras @classmethod def parse_group(cls, group, lines, dist=None): """Parse an entry point group""" if not MODULE(group): raise ValueError("Invalid group name", group) this = {} for line in yield_lines(lines): ep = cls.parse(line, dist) if ep.name in this: raise ValueError("Duplicate entry point", group, ep.name) this[ep.name] = ep return this @classmethod def parse_map(cls, data, dist=None): """Parse a map of entry point groups""" if isinstance(data, dict): data = data.items() else: data = split_sections(data) maps = {} for group, lines in data: if group is None: if not lines: continue raise ValueError("Entry points must be listed in groups") group = group.strip() if group in maps: raise ValueError("Duplicate group name", group) maps[group] = cls.parse_group(group, lines, dist) return maps def _version_from_file(lines): """ Given an iterable of lines from a Metadata file, return the value of the Version field, if present, or None otherwise. """ def is_version_line(line): return line.lower().startswith('version:') version_lines = filter(is_version_line, lines) line = next(iter(version_lines), '') _, _, value = line.partition(':') return safe_version(value.strip()) or None class Distribution: """Wrap an actual or potential sys.path entry w/metadata""" PKG_INFO = 'PKG-INFO' def __init__( self, location=None, metadata=None, project_name=None, version=None, py_version=PY_MAJOR, platform=None, precedence=EGG_DIST, ): self.project_name = safe_name(project_name or 'Unknown') if version is not None: self._version = safe_version(version) self.py_version = py_version self.platform = platform self.location = location self.precedence = precedence self._provider = metadata or empty_provider @classmethod def from_location(cls, location, basename, metadata=None, **kw): project_name, version, py_version, platform = [None] * 4 basename, ext = os.path.splitext(basename) if ext.lower() in _distributionImpl: cls = _distributionImpl[ext.lower()] match = EGG_NAME(basename) if match: project_name, version, py_version, platform = match.group( 'name', 'ver', 'pyver', 'plat' ) return cls( location, metadata, project_name=project_name, version=version, py_version=py_version, platform=platform, **kw, )._reload_version() def _reload_version(self): return self @property def hashcmp(self): return ( self._forgiving_parsed_version, self.precedence, self.key, self.location, self.py_version or '', self.platform or '', ) def __hash__(self): return hash(self.hashcmp) def __lt__(self, other): return self.hashcmp < other.hashcmp def __le__(self, other): return self.hashcmp <= other.hashcmp def __gt__(self, other): return self.hashcmp > other.hashcmp def __ge__(self, other): return self.hashcmp >= other.hashcmp def __eq__(self, other): if not isinstance(other, self.__class__): # It's not a Distribution, so they are not equal return False return self.hashcmp == other.hashcmp def __ne__(self, other): return not self == other # These properties have to be lazy so that we don't have to load any # metadata until/unless it's actually needed. (i.e., some distributions # may not know their name or version without loading PKG-INFO) @property def key(self): try: return self._key except AttributeError: self._key = key = self.project_name.lower() return key @property def parsed_version(self): if not hasattr(self, "_parsed_version"): try: self._parsed_version = parse_version(self.version) except packaging.version.InvalidVersion as ex: info = f"(package: {self.project_name})" if hasattr(ex, "add_note"): ex.add_note(info) # PEP 678 raise raise packaging.version.InvalidVersion(f"{str(ex)} {info}") from None return self._parsed_version @property def _forgiving_parsed_version(self): try: return self.parsed_version except packaging.version.InvalidVersion as ex: self._parsed_version = parse_version(_forgiving_version(self.version)) notes = "\n".join(getattr(ex, "__notes__", [])) # PEP 678 msg = f"""!!\n\n ************************************************************************* {str(ex)}\n{notes} This is a long overdue deprecation. For the time being, `pkg_resources` will use `{self._parsed_version}` as a replacement to avoid breaking existing environments, but no future compatibility is guaranteed. If you maintain package {self.project_name} you should implement the relevant changes to adequate the project to PEP 440 immediately. ************************************************************************* \n\n!! """ warnings.warn(msg, DeprecationWarning) return self._parsed_version @property def version(self): try: return self._version except AttributeError as e: version = self._get_version() if version is None: path = self._get_metadata_path_for_display(self.PKG_INFO) msg = ("Missing 'Version:' header and/or {} file at path: {}").format( self.PKG_INFO, path ) raise ValueError(msg, self) from e return version @property def _dep_map(self): """ A map of extra to its list of (direct) requirements for this distribution, including the null extra. """ try: return self.__dep_map except AttributeError: self.__dep_map = self._filter_extras(self._build_dep_map()) return self.__dep_map @staticmethod def _filter_extras(dm): """ Given a mapping of extras to dependencies, strip off environment markers and filter out any dependencies not matching the markers. """ for extra in list(filter(None, dm)): new_extra = extra reqs = dm.pop(extra) new_extra, _, marker = extra.partition(':') fails_marker = marker and ( invalid_marker(marker) or not evaluate_marker(marker) ) if fails_marker: reqs = [] new_extra = safe_extra(new_extra) or None dm.setdefault(new_extra, []).extend(reqs) return dm def _build_dep_map(self): dm = {} for name in 'requires.txt', 'depends.txt': for extra, reqs in split_sections(self._get_metadata(name)): dm.setdefault(extra, []).extend(parse_requirements(reqs)) return dm def requires(self, extras=()): """List of Requirements needed for this distro if `extras` are used""" dm = self._dep_map deps = [] deps.extend(dm.get(None, ())) for ext in extras: try: deps.extend(dm[safe_extra(ext)]) except KeyError as e: raise UnknownExtra( "%s has no such extra feature %r" % (self, ext) ) from e return deps def _get_metadata_path_for_display(self, name): """ Return the path to the given metadata file, if available. """ try: # We need to access _get_metadata_path() on the provider object # directly rather than through this class's __getattr__() # since _get_metadata_path() is marked private. path = self._provider._get_metadata_path(name) # Handle exceptions e.g. in case the distribution's metadata # provider doesn't support _get_metadata_path(). except Exception: return '[could not detect]' return path def _get_metadata(self, name): if self.has_metadata(name): for line in self.get_metadata_lines(name): yield line def _get_version(self): lines = self._get_metadata(self.PKG_INFO) version = _version_from_file(lines) return version def activate(self, path=None, replace=False): """Ensure distribution is importable on `path` (default=sys.path)""" if path is None: path = sys.path self.insert_on(path, replace=replace) if path is sys.path: fixup_namespace_packages(self.location) for pkg in self._get_metadata('namespace_packages.txt'): if pkg in sys.modules: declare_namespace(pkg) def egg_name(self): """Return what this distribution's standard .egg filename should be""" filename = "%s-%s-py%s" % ( to_filename(self.project_name), to_filename(self.version), self.py_version or PY_MAJOR, ) if self.platform: filename += '-' + self.platform return filename def __repr__(self): if self.location: return "%s (%s)" % (self, self.location) else: return str(self) def __str__(self): try: version = getattr(self, 'version', None) except ValueError: version = None version = version or "[unknown version]" return "%s %s" % (self.project_name, version) def __getattr__(self, attr): """Delegate all unrecognized public attributes to .metadata provider""" if attr.startswith('_'): raise AttributeError(attr) return getattr(self._provider, attr) def __dir__(self): return list( set(super(Distribution, self).__dir__()) | set(attr for attr in self._provider.__dir__() if not attr.startswith('_')) ) @classmethod def from_filename(cls, filename, metadata=None, **kw): return cls.from_location( _normalize_cached(filename), os.path.basename(filename), metadata, **kw ) def as_requirement(self): """Return a ``Requirement`` that matches this distribution exactly""" if isinstance(self.parsed_version, packaging.version.Version): spec = "%s==%s" % (self.project_name, self.parsed_version) else: spec = "%s===%s" % (self.project_name, self.parsed_version) return Requirement.parse(spec) def load_entry_point(self, group, name): """Return the `name` entry point of `group` or raise ImportError""" ep = self.get_entry_info(group, name) if ep is None: raise ImportError("Entry point %r not found" % ((group, name),)) return ep.load() def get_entry_map(self, group=None): """Return the entry point map for `group`, or the full entry map""" try: ep_map = self._ep_map except AttributeError: ep_map = self._ep_map = EntryPoint.parse_map( self._get_metadata('entry_points.txt'), self ) if group is not None: return ep_map.get(group, {}) return ep_map def get_entry_info(self, group, name): """Return the EntryPoint object for `group`+`name`, or ``None``""" return self.get_entry_map(group).get(name) # FIXME: 'Distribution.insert_on' is too complex (13) def insert_on(self, path, loc=None, replace=False): # noqa: C901 """Ensure self.location is on path If replace=False (default): - If location is already in path anywhere, do nothing. - Else: - If it's an egg and its parent directory is on path, insert just ahead of the parent. - Else: add to the end of path. If replace=True: - If location is already on path anywhere (not eggs) or higher priority than its parent (eggs) do nothing. - Else: - If it's an egg and its parent directory is on path, insert just ahead of the parent, removing any lower-priority entries. - Else: add it to the front of path. """ loc = loc or self.location if not loc: return nloc = _normalize_cached(loc) bdir = os.path.dirname(nloc) npath = [(p and _normalize_cached(p) or p) for p in path] for p, item in enumerate(npath): if item == nloc: if replace: break else: # don't modify path (even removing duplicates) if # found and not replace return elif item == bdir and self.precedence == EGG_DIST: # if it's an .egg, give it precedence over its directory # UNLESS it's already been added to sys.path and replace=False if (not replace) and nloc in npath[p:]: return if path is sys.path: self.check_version_conflict() path.insert(p, loc) npath.insert(p, nloc) break else: if path is sys.path: self.check_version_conflict() if replace: path.insert(0, loc) else: path.append(loc) return # p is the spot where we found or inserted loc; now remove duplicates while True: try: np = npath.index(nloc, p + 1) except ValueError: break else: del npath[np], path[np] # ha! p = np return def check_version_conflict(self): if self.key == 'setuptools': # ignore the inevitable setuptools self-conflicts :( return nsp = dict.fromkeys(self._get_metadata('namespace_packages.txt')) loc = normalize_path(self.location) for modname in self._get_metadata('top_level.txt'): if ( modname not in sys.modules or modname in nsp or modname in _namespace_packages ): continue if modname in ('pkg_resources', 'setuptools', 'site'): continue fn = getattr(sys.modules[modname], '__file__', None) if fn and ( normalize_path(fn).startswith(loc) or fn.startswith(self.location) ): continue issue_warning( "Module %s was already imported from %s, but %s is being added" " to sys.path" % (modname, fn, self.location), ) def has_version(self): try: self.version except ValueError: issue_warning("Unbuilt egg for " + repr(self)) return False except SystemError: # TODO: remove this except clause when python/cpython#103632 is fixed. return False return True def clone(self, **kw): """Copy this distribution, substituting in any changed keyword args""" names = 'project_name version py_version platform location precedence' for attr in names.split(): kw.setdefault(attr, getattr(self, attr, None)) kw.setdefault('metadata', self._provider) return self.__class__(**kw) @property def extras(self): return [dep for dep in self._dep_map if dep] class EggInfoDistribution(Distribution): def _reload_version(self): """ Packages installed by distutils (e.g. numpy or scipy), which uses an old safe_version, and so their version numbers can get mangled when converted to filenames (e.g., 1.11.0.dev0+2329eae to 1.11.0.dev0_2329eae). These distributions will not be parsed properly downstream by Distribution and safe_version, so take an extra step and try to get the version number from the metadata file itself instead of the filename. """ md_version = self._get_version() if md_version: self._version = md_version return self class DistInfoDistribution(Distribution): """ Wrap an actual or potential sys.path entry w/metadata, .dist-info style. """ PKG_INFO = 'METADATA' EQEQ = re.compile(r"([\(,])\s*(\d.*?)\s*([,\)])") @property def _parsed_pkg_info(self): """Parse and cache metadata""" try: return self._pkg_info except AttributeError: metadata = self.get_metadata(self.PKG_INFO) self._pkg_info = email.parser.Parser().parsestr(metadata) return self._pkg_info @property def _dep_map(self): try: return self.__dep_map except AttributeError: self.__dep_map = self._compute_dependencies() return self.__dep_map def _compute_dependencies(self): """Recompute this distribution's dependencies.""" dm = self.__dep_map = {None: []} reqs = [] # Including any condition expressions for req in self._parsed_pkg_info.get_all('Requires-Dist') or []: reqs.extend(parse_requirements(req)) def reqs_for_extra(extra): for req in reqs: if not req.marker or req.marker.evaluate({'extra': extra}): yield req common = types.MappingProxyType(dict.fromkeys(reqs_for_extra(None))) dm[None].extend(common) for extra in self._parsed_pkg_info.get_all('Provides-Extra') or []: s_extra = safe_extra(extra.strip()) dm[s_extra] = [r for r in reqs_for_extra(extra) if r not in common] return dm _distributionImpl = { '.egg': Distribution, '.egg-info': EggInfoDistribution, '.dist-info': DistInfoDistribution, } def issue_warning(*args, **kw): level = 1 g = globals() try: # find the first stack frame that is *not* code in # the pkg_resources module, to use for the warning while sys._getframe(level).f_globals is g: level += 1 except ValueError: pass warnings.warn(stacklevel=level + 1, *args, **kw) def parse_requirements(strs): """ Yield ``Requirement`` objects for each specification in `strs`. `strs` must be a string, or a (possibly-nested) iterable thereof. """ return map(Requirement, join_continuation(map(drop_comment, yield_lines(strs)))) class RequirementParseError(packaging.requirements.InvalidRequirement): "Compatibility wrapper for InvalidRequirement" class Requirement(packaging.requirements.Requirement): def __init__(self, requirement_string): """DO NOT CALL THIS UNDOCUMENTED METHOD; use Requirement.parse()!""" super(Requirement, self).__init__(requirement_string) self.unsafe_name = self.name project_name = safe_name(self.name) self.project_name, self.key = project_name, project_name.lower() self.specs = [(spec.operator, spec.version) for spec in self.specifier] self.extras = tuple(map(safe_extra, self.extras)) self.hashCmp = ( self.key, self.url, self.specifier, frozenset(self.extras), str(self.marker) if self.marker else None, ) self.__hash = hash(self.hashCmp) def __eq__(self, other): return isinstance(other, Requirement) and self.hashCmp == other.hashCmp def __ne__(self, other): return not self == other def __contains__(self, item): if isinstance(item, Distribution): if item.key != self.key: return False item = item.version # Allow prereleases always in order to match the previous behavior of # this method. In the future this should be smarter and follow PEP 440 # more accurately. return self.specifier.contains(item, prereleases=True) def __hash__(self): return self.__hash def __repr__(self): return "Requirement.parse(%r)" % str(self) @staticmethod def parse(s): (req,) = parse_requirements(s) return req def _always_object(classes): """ Ensure object appears in the mro even for old-style classes. """ if object not in classes: return classes + (object,) return classes def _find_adapter(registry, ob): """Return an adapter factory for `ob` from `registry`""" types = _always_object(inspect.getmro(getattr(ob, '__class__', type(ob)))) for t in types: if t in registry: return registry[t] def ensure_directory(path): """Ensure that the parent directory of `path` exists""" dirname = os.path.dirname(path) os.makedirs(dirname, exist_ok=True) def _bypass_ensure_directory(path): """Sandbox-bypassing version of ensure_directory()""" if not WRITE_SUPPORT: raise IOError('"os.mkdir" not supported on this platform.') dirname, filename = split(path) if dirname and filename and not isdir(dirname): _bypass_ensure_directory(dirname) try: mkdir(dirname, 0o755) except FileExistsError: pass def split_sections(s): """Split a string or iterable thereof into (section, content) pairs Each ``section`` is a stripped version of the section header ("[section]") and each ``content`` is a list of stripped lines excluding blank lines and comment-only lines. If there are any such lines before the first section header, they're returned in a first ``section`` of ``None``. """ section = None content = [] for line in yield_lines(s): if line.startswith("["): if line.endswith("]"): if section or content: yield section, content section = line[1:-1].strip() content = [] else: raise ValueError("Invalid section heading", line) else: content.append(line) # wrap up last segment yield section, content def _mkstemp(*args, **kw): old_open = os.open try: # temporarily bypass sandboxing os.open = os_open return tempfile.mkstemp(*args, **kw) finally: # and then put it back os.open = old_open # Silence the PEP440Warning by default, so that end users don't get hit by it # randomly just because they use pkg_resources. We want to append the rule # because we want earlier uses of filterwarnings to take precedence over this # one. warnings.filterwarnings("ignore", category=PEP440Warning, append=True) # from jaraco.functools 1.3 def _call_aside(f, *args, **kwargs): f(*args, **kwargs) return f @_call_aside def _initialize(g=globals()): "Set up global resource manager (deliberately not state-saved)" manager = ResourceManager() g['_manager'] = manager g.update( (name, getattr(manager, name)) for name in dir(manager) if not name.startswith('_') ) class PkgResourcesDeprecationWarning(Warning): """ Base class for warning about deprecations in ``pkg_resources`` This class is not derived from ``DeprecationWarning``, and as such is visible by default. """ @_call_aside def _initialize_master_working_set(): """ Prepare the master working set and make the ``require()`` API available. This function has explicit effects on the global state of pkg_resources. It is intended to be invoked once at the initialization of this module. Invocation by other packages is unsupported and done at their own risk. """ working_set = WorkingSet._build_master() _declare_state('object', working_set=working_set) require = working_set.require iter_entry_points = working_set.iter_entry_points add_activation_listener = working_set.subscribe run_script = working_set.run_script # backward compatibility run_main = run_script # Activate all distributions already on sys.path with replace=False and # ensure that all distributions added to the working set in the future # (e.g. by calling ``require()``) will get activated as well, # with higher priority (replace=True). tuple(dist.activate(replace=False) for dist in working_set) add_activation_listener( lambda dist: dist.activate(replace=True), existing=False, ) working_set.entries = [] # match order list(map(working_set.add_entry, sys.path)) globals().update(locals()) ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.491548 setuptools-68.1.2/pkg_resources/_vendor/0000755000175100001730000000000014467657443017765 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/__init__.py0000644000175100001730000000000014467657412022060 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.491548 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/0000755000175100001730000000000014467657443024060 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/__init__.py0000644000175100001730000000077214467657412026173 0ustar00runnerdocker"""Read resources contained within a package.""" from ._common import ( as_file, files, Package, ) from ._legacy import ( contents, open_binary, read_binary, open_text, read_text, is_resource, path, Resource, ) from .abc import ResourceReader __all__ = [ 'Package', 'Resource', 'ResourceReader', 'as_file', 'contents', 'files', 'is_resource', 'open_binary', 'open_text', 'path', 'read_binary', 'read_text', ] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/_adapters.py0000644000175100001730000001063014467657412026370 0ustar00runnerdockerfrom contextlib import suppress from io import TextIOWrapper from . import abc class SpecLoaderAdapter: """ Adapt a package spec to adapt the underlying loader. """ def __init__(self, spec, adapter=lambda spec: spec.loader): self.spec = spec self.loader = adapter(spec) def __getattr__(self, name): return getattr(self.spec, name) class TraversableResourcesLoader: """ Adapt a loader to provide TraversableResources. """ def __init__(self, spec): self.spec = spec def get_resource_reader(self, name): return CompatibilityFiles(self.spec)._native() def _io_wrapper(file, mode='r', *args, **kwargs): if mode == 'r': return TextIOWrapper(file, *args, **kwargs) elif mode == 'rb': return file raise ValueError( "Invalid mode value '{}', only 'r' and 'rb' are supported".format(mode) ) class CompatibilityFiles: """ Adapter for an existing or non-existent resource reader to provide a compatibility .files(). """ class SpecPath(abc.Traversable): """ Path tied to a module spec. Can be read and exposes the resource reader children. """ def __init__(self, spec, reader): self._spec = spec self._reader = reader def iterdir(self): if not self._reader: return iter(()) return iter( CompatibilityFiles.ChildPath(self._reader, path) for path in self._reader.contents() ) def is_file(self): return False is_dir = is_file def joinpath(self, other): if not self._reader: return CompatibilityFiles.OrphanPath(other) return CompatibilityFiles.ChildPath(self._reader, other) @property def name(self): return self._spec.name def open(self, mode='r', *args, **kwargs): return _io_wrapper(self._reader.open_resource(None), mode, *args, **kwargs) class ChildPath(abc.Traversable): """ Path tied to a resource reader child. Can be read but doesn't expose any meaningful children. """ def __init__(self, reader, name): self._reader = reader self._name = name def iterdir(self): return iter(()) def is_file(self): return self._reader.is_resource(self.name) def is_dir(self): return not self.is_file() def joinpath(self, other): return CompatibilityFiles.OrphanPath(self.name, other) @property def name(self): return self._name def open(self, mode='r', *args, **kwargs): return _io_wrapper( self._reader.open_resource(self.name), mode, *args, **kwargs ) class OrphanPath(abc.Traversable): """ Orphan path, not tied to a module spec or resource reader. Can't be read and doesn't expose any meaningful children. """ def __init__(self, *path_parts): if len(path_parts) < 1: raise ValueError('Need at least one path part to construct a path') self._path = path_parts def iterdir(self): return iter(()) def is_file(self): return False is_dir = is_file def joinpath(self, other): return CompatibilityFiles.OrphanPath(*self._path, other) @property def name(self): return self._path[-1] def open(self, mode='r', *args, **kwargs): raise FileNotFoundError("Can't open orphan path") def __init__(self, spec): self.spec = spec @property def _reader(self): with suppress(AttributeError): return self.spec.loader.get_resource_reader(self.spec.name) def _native(self): """ Return the native reader if it supports files(). """ reader = self._reader return reader if hasattr(reader, 'files') else self def __getattr__(self, attr): return getattr(self._reader, attr) def files(self): return CompatibilityFiles.SpecPath(self.spec, self._reader) def wrap_spec(package): """ Construct a package spec with traversable compatibility on the spec/loader/reader. """ return SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/_common.py0000644000175100001730000001252114467657412026056 0ustar00runnerdockerimport os import pathlib import tempfile import functools import contextlib import types import importlib import inspect import warnings import itertools from typing import Union, Optional, cast from .abc import ResourceReader, Traversable from ._compat import wrap_spec Package = Union[types.ModuleType, str] Anchor = Package def package_to_anchor(func): """ Replace 'package' parameter as 'anchor' and warn about the change. Other errors should fall through. >>> files('a', 'b') Traceback (most recent call last): TypeError: files() takes from 0 to 1 positional arguments but 2 were given """ undefined = object() @functools.wraps(func) def wrapper(anchor=undefined, package=undefined): if package is not undefined: if anchor is not undefined: return func(anchor, package) warnings.warn( "First parameter to files is renamed to 'anchor'", DeprecationWarning, stacklevel=2, ) return func(package) elif anchor is undefined: return func() return func(anchor) return wrapper @package_to_anchor def files(anchor: Optional[Anchor] = None) -> Traversable: """ Get a Traversable resource for an anchor. """ return from_package(resolve(anchor)) def get_resource_reader(package: types.ModuleType) -> Optional[ResourceReader]: """ Return the package's loader if it's a ResourceReader. """ # We can't use # a issubclass() check here because apparently abc.'s __subclasscheck__() # hook wants to create a weak reference to the object, but # zipimport.zipimporter does not support weak references, resulting in a # TypeError. That seems terrible. spec = package.__spec__ reader = getattr(spec.loader, 'get_resource_reader', None) # type: ignore if reader is None: return None return reader(spec.name) # type: ignore @functools.singledispatch def resolve(cand: Optional[Anchor]) -> types.ModuleType: return cast(types.ModuleType, cand) @resolve.register def _(cand: str) -> types.ModuleType: return importlib.import_module(cand) @resolve.register def _(cand: None) -> types.ModuleType: return resolve(_infer_caller().f_globals['__name__']) def _infer_caller(): """ Walk the stack and find the frame of the first caller not in this module. """ def is_this_file(frame_info): return frame_info.filename == __file__ def is_wrapper(frame_info): return frame_info.function == 'wrapper' not_this_file = itertools.filterfalse(is_this_file, inspect.stack()) # also exclude 'wrapper' due to singledispatch in the call stack callers = itertools.filterfalse(is_wrapper, not_this_file) return next(callers).frame def from_package(package: types.ModuleType): """ Return a Traversable object for the given package. """ spec = wrap_spec(package) reader = spec.loader.get_resource_reader(spec.name) return reader.files() @contextlib.contextmanager def _tempfile( reader, suffix='', # gh-93353: Keep a reference to call os.remove() in late Python # finalization. *, _os_remove=os.remove, ): # Not using tempfile.NamedTemporaryFile as it leads to deeper 'try' # blocks due to the need to close the temporary file to work on Windows # properly. fd, raw_path = tempfile.mkstemp(suffix=suffix) try: try: os.write(fd, reader()) finally: os.close(fd) del reader yield pathlib.Path(raw_path) finally: try: _os_remove(raw_path) except FileNotFoundError: pass def _temp_file(path): return _tempfile(path.read_bytes, suffix=path.name) def _is_present_dir(path: Traversable) -> bool: """ Some Traversables implement ``is_dir()`` to raise an exception (i.e. ``FileNotFoundError``) when the directory doesn't exist. This function wraps that call to always return a boolean and only return True if there's a dir and it exists. """ with contextlib.suppress(FileNotFoundError): return path.is_dir() return False @functools.singledispatch def as_file(path): """ Given a Traversable object, return that object as a path on the local file system in a context manager. """ return _temp_dir(path) if _is_present_dir(path) else _temp_file(path) @as_file.register(pathlib.Path) @contextlib.contextmanager def _(path): """ Degenerate behavior for pathlib.Path objects. """ yield path @contextlib.contextmanager def _temp_path(dir: tempfile.TemporaryDirectory): """ Wrap tempfile.TemporyDirectory to return a pathlib object. """ with dir as result: yield pathlib.Path(result) @contextlib.contextmanager def _temp_dir(path): """ Given a traversable dir, recursively replicate the whole tree to the file system in a context manager. """ assert path.is_dir() with _temp_path(tempfile.TemporaryDirectory()) as temp_dir: yield _write_contents(temp_dir, path) def _write_contents(target, source): child = target.joinpath(source.name) if source.is_dir(): child.mkdir() for item in source.iterdir(): _write_contents(child, item) else: child.write_bytes(source.read_bytes()) return child ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/_compat.py0000644000175100001730000000555514467657412026062 0ustar00runnerdocker# flake8: noqa import abc import os import sys import pathlib from contextlib import suppress from typing import Union if sys.version_info >= (3, 10): from zipfile import Path as ZipPath # type: ignore else: from ..zipp import Path as ZipPath # type: ignore try: from typing import runtime_checkable # type: ignore except ImportError: def runtime_checkable(cls): # type: ignore return cls try: from typing import Protocol # type: ignore except ImportError: Protocol = abc.ABC # type: ignore class TraversableResourcesLoader: """ Adapt loaders to provide TraversableResources and other compatibility. Used primarily for Python 3.9 and earlier where the native loaders do not yet implement TraversableResources. """ def __init__(self, spec): self.spec = spec @property def path(self): return self.spec.origin def get_resource_reader(self, name): from . import readers, _adapters def _zip_reader(spec): with suppress(AttributeError): return readers.ZipReader(spec.loader, spec.name) def _namespace_reader(spec): with suppress(AttributeError, ValueError): return readers.NamespaceReader(spec.submodule_search_locations) def _available_reader(spec): with suppress(AttributeError): return spec.loader.get_resource_reader(spec.name) def _native_reader(spec): reader = _available_reader(spec) return reader if hasattr(reader, 'files') else None def _file_reader(spec): try: path = pathlib.Path(self.path) except TypeError: return None if path.exists(): return readers.FileReader(self) return ( # native reader if it supplies 'files' _native_reader(self.spec) or # local ZipReader if a zip module _zip_reader(self.spec) or # local NamespaceReader if a namespace module _namespace_reader(self.spec) or # local FileReader _file_reader(self.spec) # fallback - adapt the spec ResourceReader to TraversableReader or _adapters.CompatibilityFiles(self.spec) ) def wrap_spec(package): """ Construct a package spec with traversable compatibility on the spec/loader/reader. Supersedes _adapters.wrap_spec to use TraversableResourcesLoader from above for older Python compatibility (<3.10). """ from . import _adapters return _adapters.SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader) if sys.version_info >= (3, 9): StrPath = Union[str, os.PathLike[str]] else: # PathLike is only subscriptable at runtime in 3.9+ StrPath = Union[str, "os.PathLike[str]"] ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/_itertools.py0000644000175100001730000000156414467657412026617 0ustar00runnerdockerfrom itertools import filterfalse from typing import ( Callable, Iterable, Iterator, Optional, Set, TypeVar, Union, ) # Type and type variable definitions _T = TypeVar('_T') _U = TypeVar('_U') def unique_everseen( iterable: Iterable[_T], key: Optional[Callable[[_T], _U]] = None ) -> Iterator[_T]: "List unique elements, preserving order. Remember all elements ever seen." # unique_everseen('AAAABBBCCDAABBB') --> A B C D # unique_everseen('ABBCcAD', str.lower) --> A B C D seen: Set[Union[_T, _U]] = set() seen_add = seen.add if key is None: for element in filterfalse(seen.__contains__, iterable): seen_add(element) yield element else: for element in iterable: k = key(element) if k not in seen: seen_add(k) yield element ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/_legacy.py0000644000175100001730000000663114467657412026037 0ustar00runnerdockerimport functools import os import pathlib import types import warnings from typing import Union, Iterable, ContextManager, BinaryIO, TextIO, Any from . import _common Package = Union[types.ModuleType, str] Resource = str def deprecated(func): @functools.wraps(func) def wrapper(*args, **kwargs): warnings.warn( f"{func.__name__} is deprecated. Use files() instead. " "Refer to https://importlib-resources.readthedocs.io" "/en/latest/using.html#migrating-from-legacy for migration advice.", DeprecationWarning, stacklevel=2, ) return func(*args, **kwargs) return wrapper def normalize_path(path: Any) -> str: """Normalize a path by ensuring it is a string. If the resulting string contains path separators, an exception is raised. """ str_path = str(path) parent, file_name = os.path.split(str_path) if parent: raise ValueError(f'{path!r} must be only a file name') return file_name @deprecated def open_binary(package: Package, resource: Resource) -> BinaryIO: """Return a file-like object opened for binary reading of the resource.""" return (_common.files(package) / normalize_path(resource)).open('rb') @deprecated def read_binary(package: Package, resource: Resource) -> bytes: """Return the binary contents of the resource.""" return (_common.files(package) / normalize_path(resource)).read_bytes() @deprecated def open_text( package: Package, resource: Resource, encoding: str = 'utf-8', errors: str = 'strict', ) -> TextIO: """Return a file-like object opened for text reading of the resource.""" return (_common.files(package) / normalize_path(resource)).open( 'r', encoding=encoding, errors=errors ) @deprecated def read_text( package: Package, resource: Resource, encoding: str = 'utf-8', errors: str = 'strict', ) -> str: """Return the decoded string of the resource. The decoding-related arguments have the same semantics as those of bytes.decode(). """ with open_text(package, resource, encoding, errors) as fp: return fp.read() @deprecated def contents(package: Package) -> Iterable[str]: """Return an iterable of entries in `package`. Note that not all entries are resources. Specifically, directories are not considered resources. Use `is_resource()` on each entry returned here to check if it is a resource or not. """ return [path.name for path in _common.files(package).iterdir()] @deprecated def is_resource(package: Package, name: str) -> bool: """True if `name` is a resource inside `package`. Directories are *not* resources. """ resource = normalize_path(name) return any( traversable.name == resource and traversable.is_file() for traversable in _common.files(package).iterdir() ) @deprecated def path( package: Package, resource: Resource, ) -> ContextManager[pathlib.Path]: """A context manager providing a file path object to the resource. If the resource does not already exist on its own on the file system, a temporary file will be created. If the file was created, the file will be deleted upon exiting the context manager (no exception is raised if the file was deleted prior to the context manager exiting). """ return _common.as_file(_common.files(package) / normalize_path(resource)) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/abc.py0000644000175100001730000001202414467657412025152 0ustar00runnerdockerimport abc import io import itertools import pathlib from typing import Any, BinaryIO, Iterable, Iterator, NoReturn, Text, Optional from ._compat import runtime_checkable, Protocol, StrPath __all__ = ["ResourceReader", "Traversable", "TraversableResources"] class ResourceReader(metaclass=abc.ABCMeta): """Abstract base class for loaders to provide resource reading support.""" @abc.abstractmethod def open_resource(self, resource: Text) -> BinaryIO: """Return an opened, file-like object for binary reading. The 'resource' argument is expected to represent only a file name. If the resource cannot be found, FileNotFoundError is raised. """ # This deliberately raises FileNotFoundError instead of # NotImplementedError so that if this method is accidentally called, # it'll still do the right thing. raise FileNotFoundError @abc.abstractmethod def resource_path(self, resource: Text) -> Text: """Return the file system path to the specified resource. The 'resource' argument is expected to represent only a file name. If the resource does not exist on the file system, raise FileNotFoundError. """ # This deliberately raises FileNotFoundError instead of # NotImplementedError so that if this method is accidentally called, # it'll still do the right thing. raise FileNotFoundError @abc.abstractmethod def is_resource(self, path: Text) -> bool: """Return True if the named 'path' is a resource. Files are resources, directories are not. """ raise FileNotFoundError @abc.abstractmethod def contents(self) -> Iterable[str]: """Return an iterable of entries in `package`.""" raise FileNotFoundError class TraversalError(Exception): pass @runtime_checkable class Traversable(Protocol): """ An object with a subset of pathlib.Path methods suitable for traversing directories and opening files. Any exceptions that occur when accessing the backing resource may propagate unaltered. """ @abc.abstractmethod def iterdir(self) -> Iterator["Traversable"]: """ Yield Traversable objects in self """ def read_bytes(self) -> bytes: """ Read contents of self as bytes """ with self.open('rb') as strm: return strm.read() def read_text(self, encoding: Optional[str] = None) -> str: """ Read contents of self as text """ with self.open(encoding=encoding) as strm: return strm.read() @abc.abstractmethod def is_dir(self) -> bool: """ Return True if self is a directory """ @abc.abstractmethod def is_file(self) -> bool: """ Return True if self is a file """ def joinpath(self, *descendants: StrPath) -> "Traversable": """ Return Traversable resolved with any descendants applied. Each descendant should be a path segment relative to self and each may contain multiple levels separated by ``posixpath.sep`` (``/``). """ if not descendants: return self names = itertools.chain.from_iterable( path.parts for path in map(pathlib.PurePosixPath, descendants) ) target = next(names) matches = ( traversable for traversable in self.iterdir() if traversable.name == target ) try: match = next(matches) except StopIteration: raise TraversalError( "Target not found during traversal.", target, list(names) ) return match.joinpath(*names) def __truediv__(self, child: StrPath) -> "Traversable": """ Return Traversable child in self """ return self.joinpath(child) @abc.abstractmethod def open(self, mode='r', *args, **kwargs): """ mode may be 'r' or 'rb' to open as text or binary. Return a handle suitable for reading (same as pathlib.Path.open). When opening as text, accepts encoding parameters such as those accepted by io.TextIOWrapper. """ @property @abc.abstractmethod def name(self) -> str: """ The base name of this object without any parent references. """ class TraversableResources(ResourceReader): """ The required interface for providing traversable resources. """ @abc.abstractmethod def files(self) -> "Traversable": """Return a Traversable object for the loaded package.""" def open_resource(self, resource: StrPath) -> io.BufferedReader: return self.files().joinpath(resource).open('rb') def resource_path(self, resource: Any) -> NoReturn: raise FileNotFoundError(resource) def is_resource(self, path: StrPath) -> bool: return self.files().joinpath(path).is_file() def contents(self) -> Iterator[str]: return (item.name for item in self.files().iterdir()) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/readers.py0000644000175100001730000000677514467657412026072 0ustar00runnerdockerimport collections import pathlib import operator from . import abc from ._itertools import unique_everseen from ._compat import ZipPath def remove_duplicates(items): return iter(collections.OrderedDict.fromkeys(items)) class FileReader(abc.TraversableResources): def __init__(self, loader): self.path = pathlib.Path(loader.path).parent def resource_path(self, resource): """ Return the file system path to prevent `resources.path()` from creating a temporary copy. """ return str(self.path.joinpath(resource)) def files(self): return self.path class ZipReader(abc.TraversableResources): def __init__(self, loader, module): _, _, name = module.rpartition('.') self.prefix = loader.prefix.replace('\\', '/') + name + '/' self.archive = loader.archive def open_resource(self, resource): try: return super().open_resource(resource) except KeyError as exc: raise FileNotFoundError(exc.args[0]) def is_resource(self, path): # workaround for `zipfile.Path.is_file` returning true # for non-existent paths. target = self.files().joinpath(path) return target.is_file() and target.exists() def files(self): return ZipPath(self.archive, self.prefix) class MultiplexedPath(abc.Traversable): """ Given a series of Traversable objects, implement a merged version of the interface across all objects. Useful for namespace packages which may be multihomed at a single name. """ def __init__(self, *paths): self._paths = list(map(pathlib.Path, remove_duplicates(paths))) if not self._paths: message = 'MultiplexedPath must contain at least one path' raise FileNotFoundError(message) if not all(path.is_dir() for path in self._paths): raise NotADirectoryError('MultiplexedPath only supports directories') def iterdir(self): files = (file for path in self._paths for file in path.iterdir()) return unique_everseen(files, key=operator.attrgetter('name')) def read_bytes(self): raise FileNotFoundError(f'{self} is not a file') def read_text(self, *args, **kwargs): raise FileNotFoundError(f'{self} is not a file') def is_dir(self): return True def is_file(self): return False def joinpath(self, *descendants): try: return super().joinpath(*descendants) except abc.TraversalError: # One of the paths did not resolve (a directory does not exist). # Just return something that will not exist. return self._paths[0].joinpath(*descendants) def open(self, *args, **kwargs): raise FileNotFoundError(f'{self} is not a file') @property def name(self): return self._paths[0].name def __repr__(self): paths = ', '.join(f"'{path}'" for path in self._paths) return f'MultiplexedPath({paths})' class NamespaceReader(abc.TraversableResources): def __init__(self, namespace_path): if 'NamespacePath' not in str(namespace_path): raise ValueError('Invalid path') self.path = MultiplexedPath(*list(namespace_path)) def resource_path(self, resource): """ Return the file system path to prevent `resources.path()` from creating a temporary copy. """ return str(self.path.joinpath(resource)) def files(self): return self.path ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/simple.py0000644000175100001730000000502014467657412025714 0ustar00runnerdocker""" Interface adapters for low-level readers. """ import abc import io import itertools from typing import BinaryIO, List from .abc import Traversable, TraversableResources class SimpleReader(abc.ABC): """ The minimum, low-level interface required from a resource provider. """ @property @abc.abstractmethod def package(self) -> str: """ The name of the package for which this reader loads resources. """ @abc.abstractmethod def children(self) -> List['SimpleReader']: """ Obtain an iterable of SimpleReader for available child containers (e.g. directories). """ @abc.abstractmethod def resources(self) -> List[str]: """ Obtain available named resources for this virtual package. """ @abc.abstractmethod def open_binary(self, resource: str) -> BinaryIO: """ Obtain a File-like for a named resource. """ @property def name(self): return self.package.split('.')[-1] class ResourceContainer(Traversable): """ Traversable container for a package's resources via its reader. """ def __init__(self, reader: SimpleReader): self.reader = reader def is_dir(self): return True def is_file(self): return False def iterdir(self): files = (ResourceHandle(self, name) for name in self.reader.resources) dirs = map(ResourceContainer, self.reader.children()) return itertools.chain(files, dirs) def open(self, *args, **kwargs): raise IsADirectoryError() class ResourceHandle(Traversable): """ Handle to a named resource in a ResourceReader. """ def __init__(self, parent: ResourceContainer, name: str): self.parent = parent self.name = name # type: ignore def is_file(self): return True def is_dir(self): return False def open(self, mode='r', *args, **kwargs): stream = self.parent.reader.open_binary(self.name) if 'b' not in mode: stream = io.TextIOWrapper(*args, **kwargs) return stream def joinpath(self, name): raise RuntimeError("Cannot traverse into a resource") class TraversableReader(TraversableResources, SimpleReader): """ A TraversableResources based on SimpleReader. Resource providers may derive from this class to provide the TraversableResources interface by supplying the SimpleReader interface. """ def files(self): return ResourceContainer(self) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/0000755000175100001730000000000014467657443025222 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/__init__.py0000644000175100001730000000000014467657412027315 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/_compat.py0000644000175100001730000000130414467657412027210 0ustar00runnerdockerimport os try: from test.support import import_helper # type: ignore except ImportError: # Python 3.9 and earlier class import_helper: # type: ignore from test.support import ( modules_setup, modules_cleanup, DirsOnSysPath, CleanImport, ) try: from test.support import os_helper # type: ignore except ImportError: # Python 3.9 compat class os_helper: # type:ignore from test.support import temp_dir try: # Python 3.10 from test.support.os_helper import unlink except ImportError: from test.support import unlink as _unlink def unlink(target): return _unlink(os.fspath(target)) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/_path.py0000644000175100001730000000201714467657412026663 0ustar00runnerdockerimport pathlib import functools #### # from jaraco.path 3.4 def build(spec, prefix=pathlib.Path()): """ Build a set of files/directories, as described by the spec. Each key represents a pathname, and the value represents the content. Content may be a nested directory. >>> spec = { ... 'README.txt': "A README file", ... "foo": { ... "__init__.py": "", ... "bar": { ... "__init__.py": "", ... }, ... "baz.py": "# Some code", ... } ... } >>> tmpdir = getfixture('tmpdir') >>> build(spec, tmpdir) """ for name, contents in spec.items(): create(contents, pathlib.Path(prefix) / name) @functools.singledispatch def create(content, path): path.mkdir(exist_ok=True) build(content, prefix=path) # type: ignore @create.register def _(content: bytes, path): path.write_bytes(content) @create.register def _(content: str, path): path.write_text(content) # end from jaraco.path #### ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data01/0000755000175100001730000000000014467657443026274 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data01/__init__.py0000644000175100001730000000000014467657412030367 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data01/subdirectory/0000755000175100001730000000000014467657443031012 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data01/subdirectory/__init__.py0000644000175100001730000000000014467657412033105 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/0000755000175100001730000000000014467657443026275 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/__init__.py0000644000175100001730000000000014467657412030370 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/one/0000755000175100001730000000000014467657443027056 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/one/__init__.py0000644000175100001730000000000014467657412031151 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/one/resource1.txt0000644000175100001730000000001514467657412031517 0ustar00runnerdockerone resource ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/two/0000755000175100001730000000000014467657443027106 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/two/__init__.py0000644000175100001730000000000014467657412031201 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/data02/two/resource2.txt0000644000175100001730000000001514467657412031550 0ustar00runnerdockertwo resource ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_compatibilty_files.py0000644000175100001730000000627414467657412032522 0ustar00runnerdockerimport io import unittest import importlib_resources as resources from importlib_resources._adapters import ( CompatibilityFiles, wrap_spec, ) from . import util class CompatibilityFilesTests(unittest.TestCase): @property def package(self): bytes_data = io.BytesIO(b'Hello, world!') return util.create_package( file=bytes_data, path='some_path', contents=('a', 'b', 'c'), ) @property def files(self): return resources.files(self.package) def test_spec_path_iter(self): self.assertEqual( sorted(path.name for path in self.files.iterdir()), ['a', 'b', 'c'], ) def test_child_path_iter(self): self.assertEqual(list((self.files / 'a').iterdir()), []) def test_orphan_path_iter(self): self.assertEqual(list((self.files / 'a' / 'a').iterdir()), []) self.assertEqual(list((self.files / 'a' / 'a' / 'a').iterdir()), []) def test_spec_path_is(self): self.assertFalse(self.files.is_file()) self.assertFalse(self.files.is_dir()) def test_child_path_is(self): self.assertTrue((self.files / 'a').is_file()) self.assertFalse((self.files / 'a').is_dir()) def test_orphan_path_is(self): self.assertFalse((self.files / 'a' / 'a').is_file()) self.assertFalse((self.files / 'a' / 'a').is_dir()) self.assertFalse((self.files / 'a' / 'a' / 'a').is_file()) self.assertFalse((self.files / 'a' / 'a' / 'a').is_dir()) def test_spec_path_name(self): self.assertEqual(self.files.name, 'testingpackage') def test_child_path_name(self): self.assertEqual((self.files / 'a').name, 'a') def test_orphan_path_name(self): self.assertEqual((self.files / 'a' / 'b').name, 'b') self.assertEqual((self.files / 'a' / 'b' / 'c').name, 'c') def test_spec_path_open(self): self.assertEqual(self.files.read_bytes(), b'Hello, world!') self.assertEqual(self.files.read_text(), 'Hello, world!') def test_child_path_open(self): self.assertEqual((self.files / 'a').read_bytes(), b'Hello, world!') self.assertEqual((self.files / 'a').read_text(), 'Hello, world!') def test_orphan_path_open(self): with self.assertRaises(FileNotFoundError): (self.files / 'a' / 'b').read_bytes() with self.assertRaises(FileNotFoundError): (self.files / 'a' / 'b' / 'c').read_bytes() def test_open_invalid_mode(self): with self.assertRaises(ValueError): self.files.open('0') def test_orphan_path_invalid(self): with self.assertRaises(ValueError): CompatibilityFiles.OrphanPath() def test_wrap_spec(self): spec = wrap_spec(self.package) self.assertIsInstance(spec.loader.get_resource_reader(None), CompatibilityFiles) class CompatibilityFilesNoReaderTests(unittest.TestCase): @property def package(self): return util.create_package_from_loader(None) @property def files(self): return resources.files(self.package) def test_spec_path_joinpath(self): self.assertIsInstance(self.files / 'a', CompatibilityFiles.OrphanPath) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_contents.py0000644000175100001730000000171014467657412030463 0ustar00runnerdockerimport unittest import importlib_resources as resources from . import data01 from . import util class ContentsTests: expected = { '__init__.py', 'binary.file', 'subdirectory', 'utf-16.file', 'utf-8.file', } def test_contents(self): contents = {path.name for path in resources.files(self.data).iterdir()} assert self.expected <= contents class ContentsDiskTests(ContentsTests, unittest.TestCase): def setUp(self): self.data = data01 class ContentsZipTests(ContentsTests, util.ZipSetup, unittest.TestCase): pass class ContentsNamespaceTests(ContentsTests, unittest.TestCase): expected = { # no __init__ because of namespace design # no subdirectory as incidental difference in fixture 'binary.file', 'utf-16.file', 'utf-8.file', } def setUp(self): from . import namespacedata01 self.data = namespacedata01 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_files.py0000644000175100001730000000626314467657412027740 0ustar00runnerdockerimport typing import textwrap import unittest import warnings import importlib import contextlib import importlib_resources as resources from ..abc import Traversable from . import data01 from . import util from . import _path from ._compat import os_helper, import_helper @contextlib.contextmanager def suppress_known_deprecation(): with warnings.catch_warnings(record=True) as ctx: warnings.simplefilter('default', category=DeprecationWarning) yield ctx class FilesTests: def test_read_bytes(self): files = resources.files(self.data) actual = files.joinpath('utf-8.file').read_bytes() assert actual == b'Hello, UTF-8 world!\n' def test_read_text(self): files = resources.files(self.data) actual = files.joinpath('utf-8.file').read_text(encoding='utf-8') assert actual == 'Hello, UTF-8 world!\n' @unittest.skipUnless( hasattr(typing, 'runtime_checkable'), "Only suitable when typing supports runtime_checkable", ) def test_traversable(self): assert isinstance(resources.files(self.data), Traversable) def test_old_parameter(self): """ Files used to take a 'package' parameter. Make sure anyone passing by name is still supported. """ with suppress_known_deprecation(): resources.files(package=self.data) class OpenDiskTests(FilesTests, unittest.TestCase): def setUp(self): self.data = data01 class OpenZipTests(FilesTests, util.ZipSetup, unittest.TestCase): pass class OpenNamespaceTests(FilesTests, unittest.TestCase): def setUp(self): from . import namespacedata01 self.data = namespacedata01 class SiteDir: def setUp(self): self.fixtures = contextlib.ExitStack() self.addCleanup(self.fixtures.close) self.site_dir = self.fixtures.enter_context(os_helper.temp_dir()) self.fixtures.enter_context(import_helper.DirsOnSysPath(self.site_dir)) self.fixtures.enter_context(import_helper.CleanImport()) class ModulesFilesTests(SiteDir, unittest.TestCase): def test_module_resources(self): """ A module can have resources found adjacent to the module. """ spec = { 'mod.py': '', 'res.txt': 'resources are the best', } _path.build(spec, self.site_dir) import mod actual = resources.files(mod).joinpath('res.txt').read_text() assert actual == spec['res.txt'] class ImplicitContextFilesTests(SiteDir, unittest.TestCase): def test_implicit_files(self): """ Without any parameter, files() will infer the location as the caller. """ spec = { 'somepkg': { '__init__.py': textwrap.dedent( """ import importlib_resources as res val = res.files().joinpath('res.txt').read_text() """ ), 'res.txt': 'resources are the best', }, } _path.build(spec, self.site_dir) assert importlib.import_module('somepkg').val == 'resources are the best' if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_open.py0000644000175100001730000000500514467657412027570 0ustar00runnerdockerimport unittest import importlib_resources as resources from . import data01 from . import util class CommonBinaryTests(util.CommonTests, unittest.TestCase): def execute(self, package, path): target = resources.files(package).joinpath(path) with target.open('rb'): pass class CommonTextTests(util.CommonTests, unittest.TestCase): def execute(self, package, path): target = resources.files(package).joinpath(path) with target.open(): pass class OpenTests: def test_open_binary(self): target = resources.files(self.data) / 'binary.file' with target.open('rb') as fp: result = fp.read() self.assertEqual(result, b'\x00\x01\x02\x03') def test_open_text_default_encoding(self): target = resources.files(self.data) / 'utf-8.file' with target.open() as fp: result = fp.read() self.assertEqual(result, 'Hello, UTF-8 world!\n') def test_open_text_given_encoding(self): target = resources.files(self.data) / 'utf-16.file' with target.open(encoding='utf-16', errors='strict') as fp: result = fp.read() self.assertEqual(result, 'Hello, UTF-16 world!\n') def test_open_text_with_errors(self): # Raises UnicodeError without the 'errors' argument. target = resources.files(self.data) / 'utf-16.file' with target.open(encoding='utf-8', errors='strict') as fp: self.assertRaises(UnicodeError, fp.read) with target.open(encoding='utf-8', errors='ignore') as fp: result = fp.read() self.assertEqual( result, 'H\x00e\x00l\x00l\x00o\x00,\x00 ' '\x00U\x00T\x00F\x00-\x001\x006\x00 ' '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00', ) def test_open_binary_FileNotFoundError(self): target = resources.files(self.data) / 'does-not-exist' self.assertRaises(FileNotFoundError, target.open, 'rb') def test_open_text_FileNotFoundError(self): target = resources.files(self.data) / 'does-not-exist' self.assertRaises(FileNotFoundError, target.open) class OpenDiskTests(OpenTests, unittest.TestCase): def setUp(self): self.data = data01 class OpenDiskNamespaceTests(OpenTests, unittest.TestCase): def setUp(self): from . import namespacedata01 self.data = namespacedata01 class OpenZipTests(OpenTests, util.ZipSetup, unittest.TestCase): pass if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_path.py0000644000175100001730000000406714467657412027572 0ustar00runnerdockerimport io import unittest import importlib_resources as resources from . import data01 from . import util class CommonTests(util.CommonTests, unittest.TestCase): def execute(self, package, path): with resources.as_file(resources.files(package).joinpath(path)): pass class PathTests: def test_reading(self): # Path should be readable. # Test also implicitly verifies the returned object is a pathlib.Path # instance. target = resources.files(self.data) / 'utf-8.file' with resources.as_file(target) as path: self.assertTrue(path.name.endswith("utf-8.file"), repr(path)) # pathlib.Path.read_text() was introduced in Python 3.5. with path.open('r', encoding='utf-8') as file: text = file.read() self.assertEqual('Hello, UTF-8 world!\n', text) class PathDiskTests(PathTests, unittest.TestCase): data = data01 def test_natural_path(self): """ Guarantee the internal implementation detail that file-system-backed resources do not get the tempdir treatment. """ target = resources.files(self.data) / 'utf-8.file' with resources.as_file(target) as path: assert 'data' in str(path) class PathMemoryTests(PathTests, unittest.TestCase): def setUp(self): file = io.BytesIO(b'Hello, UTF-8 world!\n') self.addCleanup(file.close) self.data = util.create_package( file=file, path=FileNotFoundError("package exists only in memory") ) self.data.__spec__.origin = None self.data.__spec__.has_location = False class PathZipTests(PathTests, util.ZipSetup, unittest.TestCase): def test_remove_in_context_manager(self): # It is not an error if the file that was temporarily stashed on the # file system is removed inside the `with` stanza. target = resources.files(self.data) / 'utf-8.file' with resources.as_file(target) as path: path.unlink() if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_read.py0000644000175100001730000000455014467657412027546 0ustar00runnerdockerimport unittest import importlib_resources as resources from . import data01 from . import util from importlib import import_module class CommonBinaryTests(util.CommonTests, unittest.TestCase): def execute(self, package, path): resources.files(package).joinpath(path).read_bytes() class CommonTextTests(util.CommonTests, unittest.TestCase): def execute(self, package, path): resources.files(package).joinpath(path).read_text() class ReadTests: def test_read_bytes(self): result = resources.files(self.data).joinpath('binary.file').read_bytes() self.assertEqual(result, b'\0\1\2\3') def test_read_text_default_encoding(self): result = resources.files(self.data).joinpath('utf-8.file').read_text() self.assertEqual(result, 'Hello, UTF-8 world!\n') def test_read_text_given_encoding(self): result = ( resources.files(self.data) .joinpath('utf-16.file') .read_text(encoding='utf-16') ) self.assertEqual(result, 'Hello, UTF-16 world!\n') def test_read_text_with_errors(self): # Raises UnicodeError without the 'errors' argument. target = resources.files(self.data) / 'utf-16.file' self.assertRaises(UnicodeError, target.read_text, encoding='utf-8') result = target.read_text(encoding='utf-8', errors='ignore') self.assertEqual( result, 'H\x00e\x00l\x00l\x00o\x00,\x00 ' '\x00U\x00T\x00F\x00-\x001\x006\x00 ' '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00', ) class ReadDiskTests(ReadTests, unittest.TestCase): data = data01 class ReadZipTests(ReadTests, util.ZipSetup, unittest.TestCase): def test_read_submodule_resource(self): submodule = import_module('ziptestdata.subdirectory') result = resources.files(submodule).joinpath('binary.file').read_bytes() self.assertEqual(result, b'\0\1\2\3') def test_read_submodule_resource_by_name(self): result = ( resources.files('ziptestdata.subdirectory') .joinpath('binary.file') .read_bytes() ) self.assertEqual(result, b'\0\1\2\3') class ReadNamespaceTests(ReadTests, unittest.TestCase): def setUp(self): from . import namespacedata01 self.data = namespacedata01 if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_reader.py0000644000175100001730000001060014467657412030066 0ustar00runnerdockerimport os.path import sys import pathlib import unittest from importlib import import_module from importlib_resources.readers import MultiplexedPath, NamespaceReader class MultiplexedPathTest(unittest.TestCase): @classmethod def setUpClass(cls): path = pathlib.Path(__file__).parent / 'namespacedata01' cls.folder = str(path) def test_init_no_paths(self): with self.assertRaises(FileNotFoundError): MultiplexedPath() def test_init_file(self): with self.assertRaises(NotADirectoryError): MultiplexedPath(os.path.join(self.folder, 'binary.file')) def test_iterdir(self): contents = {path.name for path in MultiplexedPath(self.folder).iterdir()} try: contents.remove('__pycache__') except (KeyError, ValueError): pass self.assertEqual(contents, {'binary.file', 'utf-16.file', 'utf-8.file'}) def test_iterdir_duplicate(self): data01 = os.path.abspath(os.path.join(__file__, '..', 'data01')) contents = { path.name for path in MultiplexedPath(self.folder, data01).iterdir() } for remove in ('__pycache__', '__init__.pyc'): try: contents.remove(remove) except (KeyError, ValueError): pass self.assertEqual( contents, {'__init__.py', 'binary.file', 'subdirectory', 'utf-16.file', 'utf-8.file'}, ) def test_is_dir(self): self.assertEqual(MultiplexedPath(self.folder).is_dir(), True) def test_is_file(self): self.assertEqual(MultiplexedPath(self.folder).is_file(), False) def test_open_file(self): path = MultiplexedPath(self.folder) with self.assertRaises(FileNotFoundError): path.read_bytes() with self.assertRaises(FileNotFoundError): path.read_text() with self.assertRaises(FileNotFoundError): path.open() def test_join_path(self): prefix = os.path.abspath(os.path.join(__file__, '..')) data01 = os.path.join(prefix, 'data01') path = MultiplexedPath(self.folder, data01) self.assertEqual( str(path.joinpath('binary.file'))[len(prefix) + 1 :], os.path.join('namespacedata01', 'binary.file'), ) self.assertEqual( str(path.joinpath('subdirectory'))[len(prefix) + 1 :], os.path.join('data01', 'subdirectory'), ) self.assertEqual( str(path.joinpath('imaginary'))[len(prefix) + 1 :], os.path.join('namespacedata01', 'imaginary'), ) self.assertEqual(path.joinpath(), path) def test_join_path_compound(self): path = MultiplexedPath(self.folder) assert not path.joinpath('imaginary/foo.py').exists() def test_repr(self): self.assertEqual( repr(MultiplexedPath(self.folder)), f"MultiplexedPath('{self.folder}')", ) def test_name(self): self.assertEqual( MultiplexedPath(self.folder).name, os.path.basename(self.folder), ) class NamespaceReaderTest(unittest.TestCase): site_dir = str(pathlib.Path(__file__).parent) @classmethod def setUpClass(cls): sys.path.append(cls.site_dir) @classmethod def tearDownClass(cls): sys.path.remove(cls.site_dir) def test_init_error(self): with self.assertRaises(ValueError): NamespaceReader(['path1', 'path2']) def test_resource_path(self): namespacedata01 = import_module('namespacedata01') reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations) root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01')) self.assertEqual( reader.resource_path('binary.file'), os.path.join(root, 'binary.file') ) self.assertEqual( reader.resource_path('imaginary'), os.path.join(root, 'imaginary') ) def test_files(self): namespacedata01 = import_module('namespacedata01') reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations) root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01')) self.assertIsInstance(reader.files(), MultiplexedPath) self.assertEqual(repr(reader.files()), f"MultiplexedPath('{root}')") if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/test_resource.py0000644000175100001730000002043614467657412030463 0ustar00runnerdockerimport sys import unittest import importlib_resources as resources import uuid import pathlib from . import data01 from . import zipdata01, zipdata02 from . import util from importlib import import_module from ._compat import import_helper, unlink class ResourceTests: # Subclasses are expected to set the `data` attribute. def test_is_file_exists(self): target = resources.files(self.data) / 'binary.file' self.assertTrue(target.is_file()) def test_is_file_missing(self): target = resources.files(self.data) / 'not-a-file' self.assertFalse(target.is_file()) def test_is_dir(self): target = resources.files(self.data) / 'subdirectory' self.assertFalse(target.is_file()) self.assertTrue(target.is_dir()) class ResourceDiskTests(ResourceTests, unittest.TestCase): def setUp(self): self.data = data01 class ResourceZipTests(ResourceTests, util.ZipSetup, unittest.TestCase): pass def names(traversable): return {item.name for item in traversable.iterdir()} class ResourceLoaderTests(unittest.TestCase): def test_resource_contents(self): package = util.create_package( file=data01, path=data01.__file__, contents=['A', 'B', 'C'] ) self.assertEqual(names(resources.files(package)), {'A', 'B', 'C'}) def test_is_file(self): package = util.create_package( file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F'] ) self.assertTrue(resources.files(package).joinpath('B').is_file()) def test_is_dir(self): package = util.create_package( file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F'] ) self.assertTrue(resources.files(package).joinpath('D').is_dir()) def test_resource_missing(self): package = util.create_package( file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F'] ) self.assertFalse(resources.files(package).joinpath('Z').is_file()) class ResourceCornerCaseTests(unittest.TestCase): def test_package_has_no_reader_fallback(self): # Test odd ball packages which: # 1. Do not have a ResourceReader as a loader # 2. Are not on the file system # 3. Are not in a zip file module = util.create_package( file=data01, path=data01.__file__, contents=['A', 'B', 'C'] ) # Give the module a dummy loader. module.__loader__ = object() # Give the module a dummy origin. module.__file__ = '/path/which/shall/not/be/named' module.__spec__.loader = module.__loader__ module.__spec__.origin = module.__file__ self.assertFalse(resources.files(module).joinpath('A').is_file()) class ResourceFromZipsTest01(util.ZipSetupBase, unittest.TestCase): ZIP_MODULE = zipdata01 # type: ignore def test_is_submodule_resource(self): submodule = import_module('ziptestdata.subdirectory') self.assertTrue(resources.files(submodule).joinpath('binary.file').is_file()) def test_read_submodule_resource_by_name(self): self.assertTrue( resources.files('ziptestdata.subdirectory') .joinpath('binary.file') .is_file() ) def test_submodule_contents(self): submodule = import_module('ziptestdata.subdirectory') self.assertEqual( names(resources.files(submodule)), {'__init__.py', 'binary.file'} ) def test_submodule_contents_by_name(self): self.assertEqual( names(resources.files('ziptestdata.subdirectory')), {'__init__.py', 'binary.file'}, ) def test_as_file_directory(self): with resources.as_file(resources.files('ziptestdata')) as data: assert data.name == 'ziptestdata' assert data.is_dir() assert data.joinpath('subdirectory').is_dir() assert len(list(data.iterdir())) assert not data.parent.exists() class ResourceFromZipsTest02(util.ZipSetupBase, unittest.TestCase): ZIP_MODULE = zipdata02 # type: ignore def test_unrelated_contents(self): """ Test thata zip with two unrelated subpackages return distinct resources. Ref python/importlib_resources#44. """ self.assertEqual( names(resources.files('ziptestdata.one')), {'__init__.py', 'resource1.txt'}, ) self.assertEqual( names(resources.files('ziptestdata.two')), {'__init__.py', 'resource2.txt'}, ) class DeletingZipsTest(unittest.TestCase): """Having accessed resources in a zip file should not keep an open reference to the zip. """ ZIP_MODULE = zipdata01 def setUp(self): modules = import_helper.modules_setup() self.addCleanup(import_helper.modules_cleanup, *modules) data_path = pathlib.Path(self.ZIP_MODULE.__file__) data_dir = data_path.parent self.source_zip_path = data_dir / 'ziptestdata.zip' self.zip_path = pathlib.Path(f'{uuid.uuid4()}.zip').absolute() self.zip_path.write_bytes(self.source_zip_path.read_bytes()) sys.path.append(str(self.zip_path)) self.data = import_module('ziptestdata') def tearDown(self): try: sys.path.remove(str(self.zip_path)) except ValueError: pass try: del sys.path_importer_cache[str(self.zip_path)] del sys.modules[self.data.__name__] except KeyError: pass try: unlink(self.zip_path) except OSError: # If the test fails, this will probably fail too pass def test_iterdir_does_not_keep_open(self): c = [item.name for item in resources.files('ziptestdata').iterdir()] self.zip_path.unlink() del c def test_is_file_does_not_keep_open(self): c = resources.files('ziptestdata').joinpath('binary.file').is_file() self.zip_path.unlink() del c def test_is_file_failure_does_not_keep_open(self): c = resources.files('ziptestdata').joinpath('not-present').is_file() self.zip_path.unlink() del c @unittest.skip("Desired but not supported.") def test_as_file_does_not_keep_open(self): # pragma: no cover c = resources.as_file(resources.files('ziptestdata') / 'binary.file') self.zip_path.unlink() del c def test_entered_path_does_not_keep_open(self): # This is what certifi does on import to make its bundle # available for the process duration. c = resources.as_file( resources.files('ziptestdata') / 'binary.file' ).__enter__() self.zip_path.unlink() del c def test_read_binary_does_not_keep_open(self): c = resources.files('ziptestdata').joinpath('binary.file').read_bytes() self.zip_path.unlink() del c def test_read_text_does_not_keep_open(self): c = resources.files('ziptestdata').joinpath('utf-8.file').read_text() self.zip_path.unlink() del c class ResourceFromNamespaceTest01(unittest.TestCase): site_dir = str(pathlib.Path(__file__).parent) @classmethod def setUpClass(cls): sys.path.append(cls.site_dir) @classmethod def tearDownClass(cls): sys.path.remove(cls.site_dir) def test_is_submodule_resource(self): self.assertTrue( resources.files(import_module('namespacedata01')) .joinpath('binary.file') .is_file() ) def test_read_submodule_resource_by_name(self): self.assertTrue( resources.files('namespacedata01').joinpath('binary.file').is_file() ) def test_submodule_contents(self): contents = names(resources.files(import_module('namespacedata01'))) try: contents.remove('__pycache__') except KeyError: pass self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'}) def test_submodule_contents_by_name(self): contents = names(resources.files('namespacedata01')) try: contents.remove('__pycache__') except KeyError: pass self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'}) if __name__ == '__main__': unittest.main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/update-zips.py0000644000175100001730000000261114467657412030035 0ustar00runnerdocker""" Generate the zip test data files. Run to build the tests/zipdataNN/ziptestdata.zip files from files in tests/dataNN. Replaces the file with the working copy, but does commit anything to the source repo. """ import contextlib import os import pathlib import zipfile def main(): """ >>> from unittest import mock >>> monkeypatch = getfixture('monkeypatch') >>> monkeypatch.setattr(zipfile, 'ZipFile', mock.MagicMock()) >>> print(); main() # print workaround for bpo-32509 ...data01... -> ziptestdata/... ... ...data02... -> ziptestdata/... ... """ suffixes = '01', '02' tuple(map(generate, suffixes)) def generate(suffix): root = pathlib.Path(__file__).parent.relative_to(os.getcwd()) zfpath = root / f'zipdata{suffix}/ziptestdata.zip' with zipfile.ZipFile(zfpath, 'w') as zf: for src, rel in walk(root / f'data{suffix}'): dst = 'ziptestdata' / pathlib.PurePosixPath(rel.as_posix()) print(src, '->', dst) zf.write(src, dst) def walk(datapath): for dirpath, dirnames, filenames in os.walk(datapath): with contextlib.suppress(ValueError): dirnames.remove('__pycache__') for filename in filenames: res = pathlib.Path(dirpath) / filename rel = res.relative_to(datapath) yield res, rel __name__ == '__main__' and main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/util.py0000644000175100001730000001141114467657412026543 0ustar00runnerdockerimport abc import importlib import io import sys import types import pathlib from . import data01 from . import zipdata01 from ..abc import ResourceReader from ._compat import import_helper from importlib.machinery import ModuleSpec class Reader(ResourceReader): def __init__(self, **kwargs): vars(self).update(kwargs) def get_resource_reader(self, package): return self def open_resource(self, path): self._path = path if isinstance(self.file, Exception): raise self.file return self.file def resource_path(self, path_): self._path = path_ if isinstance(self.path, Exception): raise self.path return self.path def is_resource(self, path_): self._path = path_ if isinstance(self.path, Exception): raise self.path def part(entry): return entry.split('/') return any( len(parts) == 1 and parts[0] == path_ for parts in map(part, self._contents) ) def contents(self): if isinstance(self.path, Exception): raise self.path yield from self._contents def create_package_from_loader(loader, is_package=True): name = 'testingpackage' module = types.ModuleType(name) spec = ModuleSpec(name, loader, origin='does-not-exist', is_package=is_package) module.__spec__ = spec module.__loader__ = loader return module def create_package(file=None, path=None, is_package=True, contents=()): return create_package_from_loader( Reader(file=file, path=path, _contents=contents), is_package, ) class CommonTests(metaclass=abc.ABCMeta): """ Tests shared by test_open, test_path, and test_read. """ @abc.abstractmethod def execute(self, package, path): """ Call the pertinent legacy API function (e.g. open_text, path) on package and path. """ def test_package_name(self): # Passing in the package name should succeed. self.execute(data01.__name__, 'utf-8.file') def test_package_object(self): # Passing in the package itself should succeed. self.execute(data01, 'utf-8.file') def test_string_path(self): # Passing in a string for the path should succeed. path = 'utf-8.file' self.execute(data01, path) def test_pathlib_path(self): # Passing in a pathlib.PurePath object for the path should succeed. path = pathlib.PurePath('utf-8.file') self.execute(data01, path) def test_importing_module_as_side_effect(self): # The anchor package can already be imported. del sys.modules[data01.__name__] self.execute(data01.__name__, 'utf-8.file') def test_missing_path(self): # Attempting to open or read or request the path for a # non-existent path should succeed if open_resource # can return a viable data stream. bytes_data = io.BytesIO(b'Hello, world!') package = create_package(file=bytes_data, path=FileNotFoundError()) self.execute(package, 'utf-8.file') self.assertEqual(package.__loader__._path, 'utf-8.file') def test_extant_path(self): # Attempting to open or read or request the path when the # path does exist should still succeed. Does not assert # anything about the result. bytes_data = io.BytesIO(b'Hello, world!') # any path that exists path = __file__ package = create_package(file=bytes_data, path=path) self.execute(package, 'utf-8.file') self.assertEqual(package.__loader__._path, 'utf-8.file') def test_useless_loader(self): package = create_package(file=FileNotFoundError(), path=FileNotFoundError()) with self.assertRaises(FileNotFoundError): self.execute(package, 'utf-8.file') class ZipSetupBase: ZIP_MODULE = None @classmethod def setUpClass(cls): data_path = pathlib.Path(cls.ZIP_MODULE.__file__) data_dir = data_path.parent cls._zip_path = str(data_dir / 'ziptestdata.zip') sys.path.append(cls._zip_path) cls.data = importlib.import_module('ziptestdata') @classmethod def tearDownClass(cls): try: sys.path.remove(cls._zip_path) except ValueError: pass try: del sys.path_importer_cache[cls._zip_path] del sys.modules[cls.data.__name__] except KeyError: pass try: del cls.data del cls._zip_path except AttributeError: pass def setUp(self): modules = import_helper.modules_setup() self.addCleanup(import_helper.modules_cleanup, *modules) class ZipSetup(ZipSetupBase): ZIP_MODULE = zipdata01 # type: ignore ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/zipdata01/0000755000175100001730000000000014467657443027017 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/zipdata01/__init__.py0000644000175100001730000000000014467657412031112 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/zipdata02/0000755000175100001730000000000014467657443027020 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources/tests/zipdata02/__init__.py0000644000175100001730000000000014467657412031113 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.491548 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources-5.10.2.dist-info/0000755000175100001730000000000014467657443026474 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/importlib_resources-5.10.2.dist-info/top_level.txt0000644000175100001730000000002414467657412031216 0ustar00runnerdockerimportlib_resources ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/jaraco/0000755000175100001730000000000014467657443021224 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco/__init__.py0000644000175100001730000000000014467657412023317 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco/context.py0000644000175100001730000001644414467657412023267 0ustar00runnerdockerimport os import subprocess import contextlib import functools import tempfile import shutil import operator import warnings @contextlib.contextmanager def pushd(dir): """ >>> tmp_path = getfixture('tmp_path') >>> with pushd(tmp_path): ... assert os.getcwd() == os.fspath(tmp_path) >>> assert os.getcwd() != os.fspath(tmp_path) """ orig = os.getcwd() os.chdir(dir) try: yield dir finally: os.chdir(orig) @contextlib.contextmanager def tarball_context(url, target_dir=None, runner=None, pushd=pushd): """ Get a tarball, extract it, change to that directory, yield, then clean up. `runner` is the function to invoke commands. `pushd` is a context manager for changing the directory. """ if target_dir is None: target_dir = os.path.basename(url).replace('.tar.gz', '').replace('.tgz', '') if runner is None: runner = functools.partial(subprocess.check_call, shell=True) else: warnings.warn("runner parameter is deprecated", DeprecationWarning) # In the tar command, use --strip-components=1 to strip the first path and # then # use -C to cause the files to be extracted to {target_dir}. This ensures # that we always know where the files were extracted. runner('mkdir {target_dir}'.format(**vars())) try: getter = 'wget {url} -O -' extract = 'tar x{compression} --strip-components=1 -C {target_dir}' cmd = ' | '.join((getter, extract)) runner(cmd.format(compression=infer_compression(url), **vars())) with pushd(target_dir): yield target_dir finally: runner('rm -Rf {target_dir}'.format(**vars())) def infer_compression(url): """ Given a URL or filename, infer the compression code for tar. >>> infer_compression('http://foo/bar.tar.gz') 'z' >>> infer_compression('http://foo/bar.tgz') 'z' >>> infer_compression('file.bz') 'j' >>> infer_compression('file.xz') 'J' """ # cheat and just assume it's the last two characters compression_indicator = url[-2:] mapping = dict(gz='z', bz='j', xz='J') # Assume 'z' (gzip) if no match return mapping.get(compression_indicator, 'z') @contextlib.contextmanager def temp_dir(remover=shutil.rmtree): """ Create a temporary directory context. Pass a custom remover to override the removal behavior. >>> import pathlib >>> with temp_dir() as the_dir: ... assert os.path.isdir(the_dir) ... _ = pathlib.Path(the_dir).joinpath('somefile').write_text('contents') >>> assert not os.path.exists(the_dir) """ temp_dir = tempfile.mkdtemp() try: yield temp_dir finally: remover(temp_dir) @contextlib.contextmanager def repo_context(url, branch=None, quiet=True, dest_ctx=temp_dir): """ Check out the repo indicated by url. If dest_ctx is supplied, it should be a context manager to yield the target directory for the check out. """ exe = 'git' if 'git' in url else 'hg' with dest_ctx() as repo_dir: cmd = [exe, 'clone', url, repo_dir] if branch: cmd.extend(['--branch', branch]) devnull = open(os.path.devnull, 'w') stdout = devnull if quiet else None subprocess.check_call(cmd, stdout=stdout) yield repo_dir @contextlib.contextmanager def null(): """ A null context suitable to stand in for a meaningful context. >>> with null() as value: ... assert value is None """ yield class ExceptionTrap: """ A context manager that will catch certain exceptions and provide an indication they occurred. >>> with ExceptionTrap() as trap: ... raise Exception() >>> bool(trap) True >>> with ExceptionTrap() as trap: ... pass >>> bool(trap) False >>> with ExceptionTrap(ValueError) as trap: ... raise ValueError("1 + 1 is not 3") >>> bool(trap) True >>> trap.value ValueError('1 + 1 is not 3') >>> trap.tb >>> with ExceptionTrap(ValueError) as trap: ... raise Exception() Traceback (most recent call last): ... Exception >>> bool(trap) False """ exc_info = None, None, None def __init__(self, exceptions=(Exception,)): self.exceptions = exceptions def __enter__(self): return self @property def type(self): return self.exc_info[0] @property def value(self): return self.exc_info[1] @property def tb(self): return self.exc_info[2] def __exit__(self, *exc_info): type = exc_info[0] matches = type and issubclass(type, self.exceptions) if matches: self.exc_info = exc_info return matches def __bool__(self): return bool(self.type) def raises(self, func, *, _test=bool): """ Wrap func and replace the result with the truth value of the trap (True if an exception occurred). First, give the decorator an alias to support Python 3.8 Syntax. >>> raises = ExceptionTrap(ValueError).raises Now decorate a function that always fails. >>> @raises ... def fail(): ... raise ValueError('failed') >>> fail() True """ @functools.wraps(func) def wrapper(*args, **kwargs): with ExceptionTrap(self.exceptions) as trap: func(*args, **kwargs) return _test(trap) return wrapper def passes(self, func): """ Wrap func and replace the result with the truth value of the trap (True if no exception). First, give the decorator an alias to support Python 3.8 Syntax. >>> passes = ExceptionTrap(ValueError).passes Now decorate a function that always fails. >>> @passes ... def fail(): ... raise ValueError('failed') >>> fail() False """ return self.raises(func, _test=operator.not_) class suppress(contextlib.suppress, contextlib.ContextDecorator): """ A version of contextlib.suppress with decorator support. >>> @suppress(KeyError) ... def key_error(): ... {}[''] >>> key_error() """ class on_interrupt(contextlib.ContextDecorator): """ Replace a KeyboardInterrupt with SystemExit(1) >>> def do_interrupt(): ... raise KeyboardInterrupt() >>> on_interrupt('error')(do_interrupt)() Traceback (most recent call last): ... SystemExit: 1 >>> on_interrupt('error', code=255)(do_interrupt)() Traceback (most recent call last): ... SystemExit: 255 >>> on_interrupt('suppress')(do_interrupt)() >>> with __import__('pytest').raises(KeyboardInterrupt): ... on_interrupt('ignore')(do_interrupt)() """ def __init__( self, action='error', # py3.7 compat # /, code=1, ): self.action = action self.code = code def __enter__(self): return self def __exit__(self, exctype, excinst, exctb): if exctype is not KeyboardInterrupt or self.action == 'ignore': return elif self.action == 'error': raise SystemExit(self.code) from excinst return self.action == 'suppress' ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco/functools.py0000644000175100001730000003532014467657412023611 0ustar00runnerdockerimport functools import time import inspect import collections import types import itertools import warnings import pkg_resources.extern.more_itertools from typing import Callable, TypeVar CallableT = TypeVar("CallableT", bound=Callable[..., object]) def compose(*funcs): """ Compose any number of unary functions into a single unary function. >>> import textwrap >>> expected = str.strip(textwrap.dedent(compose.__doc__)) >>> strip_and_dedent = compose(str.strip, textwrap.dedent) >>> strip_and_dedent(compose.__doc__) == expected True Compose also allows the innermost function to take arbitrary arguments. >>> round_three = lambda x: round(x, ndigits=3) >>> f = compose(round_three, int.__truediv__) >>> [f(3*x, x+1) for x in range(1,10)] [1.5, 2.0, 2.25, 2.4, 2.5, 2.571, 2.625, 2.667, 2.7] """ def compose_two(f1, f2): return lambda *args, **kwargs: f1(f2(*args, **kwargs)) return functools.reduce(compose_two, funcs) def method_caller(method_name, *args, **kwargs): """ Return a function that will call a named method on the target object with optional positional and keyword arguments. >>> lower = method_caller('lower') >>> lower('MyString') 'mystring' """ def call_method(target): func = getattr(target, method_name) return func(*args, **kwargs) return call_method def once(func): """ Decorate func so it's only ever called the first time. This decorator can ensure that an expensive or non-idempotent function will not be expensive on subsequent calls and is idempotent. >>> add_three = once(lambda a: a+3) >>> add_three(3) 6 >>> add_three(9) 6 >>> add_three('12') 6 To reset the stored value, simply clear the property ``saved_result``. >>> del add_three.saved_result >>> add_three(9) 12 >>> add_three(8) 12 Or invoke 'reset()' on it. >>> add_three.reset() >>> add_three(-3) 0 >>> add_three(0) 0 """ @functools.wraps(func) def wrapper(*args, **kwargs): if not hasattr(wrapper, 'saved_result'): wrapper.saved_result = func(*args, **kwargs) return wrapper.saved_result wrapper.reset = lambda: vars(wrapper).__delitem__('saved_result') return wrapper def method_cache( method: CallableT, cache_wrapper: Callable[ [CallableT], CallableT ] = functools.lru_cache(), # type: ignore[assignment] ) -> CallableT: """ Wrap lru_cache to support storing the cache data in the object instances. Abstracts the common paradigm where the method explicitly saves an underscore-prefixed protected property on first call and returns that subsequently. >>> class MyClass: ... calls = 0 ... ... @method_cache ... def method(self, value): ... self.calls += 1 ... return value >>> a = MyClass() >>> a.method(3) 3 >>> for x in range(75): ... res = a.method(x) >>> a.calls 75 Note that the apparent behavior will be exactly like that of lru_cache except that the cache is stored on each instance, so values in one instance will not flush values from another, and when an instance is deleted, so are the cached values for that instance. >>> b = MyClass() >>> for x in range(35): ... res = b.method(x) >>> b.calls 35 >>> a.method(0) 0 >>> a.calls 75 Note that if method had been decorated with ``functools.lru_cache()``, a.calls would have been 76 (due to the cached value of 0 having been flushed by the 'b' instance). Clear the cache with ``.cache_clear()`` >>> a.method.cache_clear() Same for a method that hasn't yet been called. >>> c = MyClass() >>> c.method.cache_clear() Another cache wrapper may be supplied: >>> cache = functools.lru_cache(maxsize=2) >>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache) >>> a = MyClass() >>> a.method2() 3 Caution - do not subsequently wrap the method with another decorator, such as ``@property``, which changes the semantics of the function. See also http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/ for another implementation and additional justification. """ def wrapper(self: object, *args: object, **kwargs: object) -> object: # it's the first call, replace the method with a cached, bound method bound_method: CallableT = types.MethodType( # type: ignore[assignment] method, self ) cached_method = cache_wrapper(bound_method) setattr(self, method.__name__, cached_method) return cached_method(*args, **kwargs) # Support cache clear even before cache has been created. wrapper.cache_clear = lambda: None # type: ignore[attr-defined] return ( # type: ignore[return-value] _special_method_cache(method, cache_wrapper) or wrapper ) def _special_method_cache(method, cache_wrapper): """ Because Python treats special methods differently, it's not possible to use instance attributes to implement the cached methods. Instead, install the wrapper method under a different name and return a simple proxy to that wrapper. https://github.com/jaraco/jaraco.functools/issues/5 """ name = method.__name__ special_names = '__getattr__', '__getitem__' if name not in special_names: return wrapper_name = '__cached' + name def proxy(self, *args, **kwargs): if wrapper_name not in vars(self): bound = types.MethodType(method, self) cache = cache_wrapper(bound) setattr(self, wrapper_name, cache) else: cache = getattr(self, wrapper_name) return cache(*args, **kwargs) return proxy def apply(transform): """ Decorate a function with a transform function that is invoked on results returned from the decorated function. >>> @apply(reversed) ... def get_numbers(start): ... "doc for get_numbers" ... return range(start, start+3) >>> list(get_numbers(4)) [6, 5, 4] >>> get_numbers.__doc__ 'doc for get_numbers' """ def wrap(func): return functools.wraps(func)(compose(transform, func)) return wrap def result_invoke(action): r""" Decorate a function with an action function that is invoked on the results returned from the decorated function (for its side-effect), then return the original result. >>> @result_invoke(print) ... def add_two(a, b): ... return a + b >>> x = add_two(2, 3) 5 >>> x 5 """ def wrap(func): @functools.wraps(func) def wrapper(*args, **kwargs): result = func(*args, **kwargs) action(result) return result return wrapper return wrap def invoke(f, *args, **kwargs): """ Call a function for its side effect after initialization. The benefit of using the decorator instead of simply invoking a function after defining it is that it makes explicit the author's intent for the function to be called immediately. Whereas if one simply calls the function immediately, it's less obvious if that was intentional or incidental. It also avoids repeating the name - the two actions, defining the function and calling it immediately are modeled separately, but linked by the decorator construct. The benefit of having a function construct (opposed to just invoking some behavior inline) is to serve as a scope in which the behavior occurs. It avoids polluting the global namespace with local variables, provides an anchor on which to attach documentation (docstring), keeps the behavior logically separated (instead of conceptually separated or not separated at all), and provides potential to re-use the behavior for testing or other purposes. This function is named as a pithy way to communicate, "call this function primarily for its side effect", or "while defining this function, also take it aside and call it". It exists because there's no Python construct for "define and call" (nor should there be, as decorators serve this need just fine). The behavior happens immediately and synchronously. >>> @invoke ... def func(): print("called") called >>> func() called Use functools.partial to pass parameters to the initial call >>> @functools.partial(invoke, name='bingo') ... def func(name): print("called with", name) called with bingo """ f(*args, **kwargs) return f def call_aside(*args, **kwargs): """ Deprecated name for invoke. """ warnings.warn("call_aside is deprecated, use invoke", DeprecationWarning) return invoke(*args, **kwargs) class Throttler: """ Rate-limit a function (or other callable) """ def __init__(self, func, max_rate=float('Inf')): if isinstance(func, Throttler): func = func.func self.func = func self.max_rate = max_rate self.reset() def reset(self): self.last_called = 0 def __call__(self, *args, **kwargs): self._wait() return self.func(*args, **kwargs) def _wait(self): "ensure at least 1/max_rate seconds from last call" elapsed = time.time() - self.last_called must_wait = 1 / self.max_rate - elapsed time.sleep(max(0, must_wait)) self.last_called = time.time() def __get__(self, obj, type=None): return first_invoke(self._wait, functools.partial(self.func, obj)) def first_invoke(func1, func2): """ Return a function that when invoked will invoke func1 without any parameters (for its side-effect) and then invoke func2 with whatever parameters were passed, returning its result. """ def wrapper(*args, **kwargs): func1() return func2(*args, **kwargs) return wrapper def retry_call(func, cleanup=lambda: None, retries=0, trap=()): """ Given a callable func, trap the indicated exceptions for up to 'retries' times, invoking cleanup on the exception. On the final attempt, allow any exceptions to propagate. """ attempts = itertools.count() if retries == float('inf') else range(retries) for attempt in attempts: try: return func() except trap: cleanup() return func() def retry(*r_args, **r_kwargs): """ Decorator wrapper for retry_call. Accepts arguments to retry_call except func and then returns a decorator for the decorated function. Ex: >>> @retry(retries=3) ... def my_func(a, b): ... "this is my funk" ... print(a, b) >>> my_func.__doc__ 'this is my funk' """ def decorate(func): @functools.wraps(func) def wrapper(*f_args, **f_kwargs): bound = functools.partial(func, *f_args, **f_kwargs) return retry_call(bound, *r_args, **r_kwargs) return wrapper return decorate def print_yielded(func): """ Convert a generator into a function that prints all yielded elements >>> @print_yielded ... def x(): ... yield 3; yield None >>> x() 3 None """ print_all = functools.partial(map, print) print_results = compose(more_itertools.consume, print_all, func) return functools.wraps(func)(print_results) def pass_none(func): """ Wrap func so it's not called if its first param is None >>> print_text = pass_none(print) >>> print_text('text') text >>> print_text(None) """ @functools.wraps(func) def wrapper(param, *args, **kwargs): if param is not None: return func(param, *args, **kwargs) return wrapper def assign_params(func, namespace): """ Assign parameters from namespace where func solicits. >>> def func(x, y=3): ... print(x, y) >>> assigned = assign_params(func, dict(x=2, z=4)) >>> assigned() 2 3 The usual errors are raised if a function doesn't receive its required parameters: >>> assigned = assign_params(func, dict(y=3, z=4)) >>> assigned() Traceback (most recent call last): TypeError: func() ...argument... It even works on methods: >>> class Handler: ... def meth(self, arg): ... print(arg) >>> assign_params(Handler().meth, dict(arg='crystal', foo='clear'))() crystal """ sig = inspect.signature(func) params = sig.parameters.keys() call_ns = {k: namespace[k] for k in params if k in namespace} return functools.partial(func, **call_ns) def save_method_args(method): """ Wrap a method such that when it is called, the args and kwargs are saved on the method. >>> class MyClass: ... @save_method_args ... def method(self, a, b): ... print(a, b) >>> my_ob = MyClass() >>> my_ob.method(1, 2) 1 2 >>> my_ob._saved_method.args (1, 2) >>> my_ob._saved_method.kwargs {} >>> my_ob.method(a=3, b='foo') 3 foo >>> my_ob._saved_method.args () >>> my_ob._saved_method.kwargs == dict(a=3, b='foo') True The arguments are stored on the instance, allowing for different instance to save different args. >>> your_ob = MyClass() >>> your_ob.method({str('x'): 3}, b=[4]) {'x': 3} [4] >>> your_ob._saved_method.args ({'x': 3},) >>> my_ob._saved_method.args () """ args_and_kwargs = collections.namedtuple('args_and_kwargs', 'args kwargs') @functools.wraps(method) def wrapper(self, *args, **kwargs): attr_name = '_saved_' + method.__name__ attr = args_and_kwargs(args, kwargs) setattr(self, attr_name, attr) return method(self, *args, **kwargs) return wrapper def except_(*exceptions, replace=None, use=None): """ Replace the indicated exceptions, if raised, with the indicated literal replacement or evaluated expression (if present). >>> safe_int = except_(ValueError)(int) >>> safe_int('five') >>> safe_int('5') 5 Specify a literal replacement with ``replace``. >>> safe_int_r = except_(ValueError, replace=0)(int) >>> safe_int_r('five') 0 Provide an expression to ``use`` to pass through particular parameters. >>> safe_int_pt = except_(ValueError, use='args[0]')(int) >>> safe_int_pt('five') 'five' """ def decorate(func): @functools.wraps(func) def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except exceptions: try: return eval(use) except TypeError: return replace return wrapper return decorate ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/jaraco/text/0000755000175100001730000000000014467657443022210 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco/text/Lorem ipsum.txt0000644000175100001730000000246714467657412025152 0ustar00runnerdockerLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra, est eros bibendum elit, nec luctus magna felis sollicitudin mauris. Integer in mauris eu nibh euismod gravida. Duis ac tellus et risus vulputate vehicula. Donec lobortis risus a elit. Etiam tempor. Ut ullamcorper, ligula eu tempor congue, eros est euismod turpis, id tincidunt sapien risus a quam. Maecenas fermentum consequat mi. Donec fermentum. Pellentesque malesuada nulla a mi. Duis sapien sem, aliquet nec, commodo eget, consequat quis, neque. Aliquam faucibus, elit ut dictum aliquet, felis nisl adipiscing sapien, sed malesuada diam lacus eget erat. Cras mollis scelerisque nunc. Nullam arcu. Aliquam consequat. Curabitur augue lorem, dapibus quis, laoreet et, pretium ac, nisi. Aenean magna nisl, mollis quis, molestie eu, feugiat in, orci. In hac habitasse platea dictumst. ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco/text/__init__.py0000644000175100001730000003624614467657412024330 0ustar00runnerdockerimport re import itertools import textwrap import functools try: from importlib.resources import files # type: ignore except ImportError: # pragma: nocover from pkg_resources.extern.importlib_resources import files # type: ignore from pkg_resources.extern.jaraco.functools import compose, method_cache from pkg_resources.extern.jaraco.context import ExceptionTrap def substitution(old, new): """ Return a function that will perform a substitution on a string """ return lambda s: s.replace(old, new) def multi_substitution(*substitutions): """ Take a sequence of pairs specifying substitutions, and create a function that performs those substitutions. >>> multi_substitution(('foo', 'bar'), ('bar', 'baz'))('foo') 'baz' """ substitutions = itertools.starmap(substitution, substitutions) # compose function applies last function first, so reverse the # substitutions to get the expected order. substitutions = reversed(tuple(substitutions)) return compose(*substitutions) class FoldedCase(str): """ A case insensitive string class; behaves just like str except compares equal when the only variation is case. >>> s = FoldedCase('hello world') >>> s == 'Hello World' True >>> 'Hello World' == s True >>> s != 'Hello World' False >>> s.index('O') 4 >>> s.split('O') ['hell', ' w', 'rld'] >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta'])) ['alpha', 'Beta', 'GAMMA'] Sequence membership is straightforward. >>> "Hello World" in [s] True >>> s in ["Hello World"] True You may test for set inclusion, but candidate and elements must both be folded. >>> FoldedCase("Hello World") in {s} True >>> s in {FoldedCase("Hello World")} True String inclusion works as long as the FoldedCase object is on the right. >>> "hello" in FoldedCase("Hello World") True But not if the FoldedCase object is on the left: >>> FoldedCase('hello') in 'Hello World' False In that case, use ``in_``: >>> FoldedCase('hello').in_('Hello World') True >>> FoldedCase('hello') > FoldedCase('Hello') False """ def __lt__(self, other): return self.lower() < other.lower() def __gt__(self, other): return self.lower() > other.lower() def __eq__(self, other): return self.lower() == other.lower() def __ne__(self, other): return self.lower() != other.lower() def __hash__(self): return hash(self.lower()) def __contains__(self, other): return super().lower().__contains__(other.lower()) def in_(self, other): "Does self appear in other?" return self in FoldedCase(other) # cache lower since it's likely to be called frequently. @method_cache def lower(self): return super().lower() def index(self, sub): return self.lower().index(sub.lower()) def split(self, splitter=' ', maxsplit=0): pattern = re.compile(re.escape(splitter), re.I) return pattern.split(self, maxsplit) # Python 3.8 compatibility _unicode_trap = ExceptionTrap(UnicodeDecodeError) @_unicode_trap.passes def is_decodable(value): r""" Return True if the supplied value is decodable (using the default encoding). >>> is_decodable(b'\xff') False >>> is_decodable(b'\x32') True """ value.decode() def is_binary(value): r""" Return True if the value appears to be binary (that is, it's a byte string and isn't decodable). >>> is_binary(b'\xff') True >>> is_binary('\xff') False """ return isinstance(value, bytes) and not is_decodable(value) def trim(s): r""" Trim something like a docstring to remove the whitespace that is common due to indentation and formatting. >>> trim("\n\tfoo = bar\n\t\tbar = baz\n") 'foo = bar\n\tbar = baz' """ return textwrap.dedent(s).strip() def wrap(s): """ Wrap lines of text, retaining existing newlines as paragraph markers. >>> print(wrap(lorem_ipsum)) Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum. Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra, est eros bibendum elit, nec luctus magna felis sollicitudin mauris. Integer in mauris eu nibh euismod gravida. Duis ac tellus et risus vulputate vehicula. Donec lobortis risus a elit. Etiam tempor. Ut ullamcorper, ligula eu tempor congue, eros est euismod turpis, id tincidunt sapien risus a quam. Maecenas fermentum consequat mi. Donec fermentum. Pellentesque malesuada nulla a mi. Duis sapien sem, aliquet nec, commodo eget, consequat quis, neque. Aliquam faucibus, elit ut dictum aliquet, felis nisl adipiscing sapien, sed malesuada diam lacus eget erat. Cras mollis scelerisque nunc. Nullam arcu. Aliquam consequat. Curabitur augue lorem, dapibus quis, laoreet et, pretium ac, nisi. Aenean magna nisl, mollis quis, molestie eu, feugiat in, orci. In hac habitasse platea dictumst. """ paragraphs = s.splitlines() wrapped = ('\n'.join(textwrap.wrap(para)) for para in paragraphs) return '\n\n'.join(wrapped) def unwrap(s): r""" Given a multi-line string, return an unwrapped version. >>> wrapped = wrap(lorem_ipsum) >>> wrapped.count('\n') 20 >>> unwrapped = unwrap(wrapped) >>> unwrapped.count('\n') 1 >>> print(unwrapped) Lorem ipsum dolor sit amet, consectetur adipiscing ... Curabitur pretium tincidunt lacus. Nulla gravida orci ... """ paragraphs = re.split(r'\n\n+', s) cleaned = (para.replace('\n', ' ') for para in paragraphs) return '\n'.join(cleaned) class Splitter(object): """object that will split a string with the given arguments for each call >>> s = Splitter(',') >>> s('hello, world, this is your, master calling') ['hello', ' world', ' this is your', ' master calling'] """ def __init__(self, *args): self.args = args def __call__(self, s): return s.split(*self.args) def indent(string, prefix=' ' * 4): """ >>> indent('foo') ' foo' """ return prefix + string class WordSet(tuple): """ Given an identifier, return the words that identifier represents, whether in camel case, underscore-separated, etc. >>> WordSet.parse("camelCase") ('camel', 'Case') >>> WordSet.parse("under_sep") ('under', 'sep') Acronyms should be retained >>> WordSet.parse("firstSNL") ('first', 'SNL') >>> WordSet.parse("you_and_I") ('you', 'and', 'I') >>> WordSet.parse("A simple test") ('A', 'simple', 'test') Multiple caps should not interfere with the first cap of another word. >>> WordSet.parse("myABCClass") ('my', 'ABC', 'Class') The result is a WordSet, so you can get the form you need. >>> WordSet.parse("myABCClass").underscore_separated() 'my_ABC_Class' >>> WordSet.parse('a-command').camel_case() 'ACommand' >>> WordSet.parse('someIdentifier').lowered().space_separated() 'some identifier' Slices of the result should return another WordSet. >>> WordSet.parse('taken-out-of-context')[1:].underscore_separated() 'out_of_context' >>> WordSet.from_class_name(WordSet()).lowered().space_separated() 'word set' >>> example = WordSet.parse('figured it out') >>> example.headless_camel_case() 'figuredItOut' >>> example.dash_separated() 'figured-it-out' """ _pattern = re.compile('([A-Z]?[a-z]+)|([A-Z]+(?![a-z]))') def capitalized(self): return WordSet(word.capitalize() for word in self) def lowered(self): return WordSet(word.lower() for word in self) def camel_case(self): return ''.join(self.capitalized()) def headless_camel_case(self): words = iter(self) first = next(words).lower() new_words = itertools.chain((first,), WordSet(words).camel_case()) return ''.join(new_words) def underscore_separated(self): return '_'.join(self) def dash_separated(self): return '-'.join(self) def space_separated(self): return ' '.join(self) def trim_right(self, item): """ Remove the item from the end of the set. >>> WordSet.parse('foo bar').trim_right('foo') ('foo', 'bar') >>> WordSet.parse('foo bar').trim_right('bar') ('foo',) >>> WordSet.parse('').trim_right('bar') () """ return self[:-1] if self and self[-1] == item else self def trim_left(self, item): """ Remove the item from the beginning of the set. >>> WordSet.parse('foo bar').trim_left('foo') ('bar',) >>> WordSet.parse('foo bar').trim_left('bar') ('foo', 'bar') >>> WordSet.parse('').trim_left('bar') () """ return self[1:] if self and self[0] == item else self def trim(self, item): """ >>> WordSet.parse('foo bar').trim('foo') ('bar',) """ return self.trim_left(item).trim_right(item) def __getitem__(self, item): result = super(WordSet, self).__getitem__(item) if isinstance(item, slice): result = WordSet(result) return result @classmethod def parse(cls, identifier): matches = cls._pattern.finditer(identifier) return WordSet(match.group(0) for match in matches) @classmethod def from_class_name(cls, subject): return cls.parse(subject.__class__.__name__) # for backward compatibility words = WordSet.parse def simple_html_strip(s): r""" Remove HTML from the string `s`. >>> str(simple_html_strip('')) '' >>> print(simple_html_strip('A stormy day in paradise')) A stormy day in paradise >>> print(simple_html_strip('Somebody tell the truth.')) Somebody tell the truth. >>> print(simple_html_strip('What about
\nmultiple lines?')) What about multiple lines? """ html_stripper = re.compile('()|(<[^>]*>)|([^<]+)', re.DOTALL) texts = (match.group(3) or '' for match in html_stripper.finditer(s)) return ''.join(texts) class SeparatedValues(str): """ A string separated by a separator. Overrides __iter__ for getting the values. >>> list(SeparatedValues('a,b,c')) ['a', 'b', 'c'] Whitespace is stripped and empty values are discarded. >>> list(SeparatedValues(' a, b , c, ')) ['a', 'b', 'c'] """ separator = ',' def __iter__(self): parts = self.split(self.separator) return filter(None, (part.strip() for part in parts)) class Stripper: r""" Given a series of lines, find the common prefix and strip it from them. >>> lines = [ ... 'abcdefg\n', ... 'abc\n', ... 'abcde\n', ... ] >>> res = Stripper.strip_prefix(lines) >>> res.prefix 'abc' >>> list(res.lines) ['defg\n', '\n', 'de\n'] If no prefix is common, nothing should be stripped. >>> lines = [ ... 'abcd\n', ... '1234\n', ... ] >>> res = Stripper.strip_prefix(lines) >>> res.prefix = '' >>> list(res.lines) ['abcd\n', '1234\n'] """ def __init__(self, prefix, lines): self.prefix = prefix self.lines = map(self, lines) @classmethod def strip_prefix(cls, lines): prefix_lines, lines = itertools.tee(lines) prefix = functools.reduce(cls.common_prefix, prefix_lines) return cls(prefix, lines) def __call__(self, line): if not self.prefix: return line null, prefix, rest = line.partition(self.prefix) return rest @staticmethod def common_prefix(s1, s2): """ Return the common prefix of two lines. """ index = min(len(s1), len(s2)) while s1[:index] != s2[:index]: index -= 1 return s1[:index] def remove_prefix(text, prefix): """ Remove the prefix from the text if it exists. >>> remove_prefix('underwhelming performance', 'underwhelming ') 'performance' >>> remove_prefix('something special', 'sample') 'something special' """ null, prefix, rest = text.rpartition(prefix) return rest def remove_suffix(text, suffix): """ Remove the suffix from the text if it exists. >>> remove_suffix('name.git', '.git') 'name' >>> remove_suffix('something special', 'sample') 'something special' """ rest, suffix, null = text.partition(suffix) return rest def normalize_newlines(text): r""" Replace alternate newlines with the canonical newline. >>> normalize_newlines('Lorem Ipsum\u2029') 'Lorem Ipsum\n' >>> normalize_newlines('Lorem Ipsum\r\n') 'Lorem Ipsum\n' >>> normalize_newlines('Lorem Ipsum\x85') 'Lorem Ipsum\n' """ newlines = ['\r\n', '\r', '\n', '\u0085', '\u2028', '\u2029'] pattern = '|'.join(newlines) return re.sub(pattern, '\n', text) def _nonblank(str): return str and not str.startswith('#') @functools.singledispatch def yield_lines(iterable): r""" Yield valid lines of a string or iterable. >>> list(yield_lines('')) [] >>> list(yield_lines(['foo', 'bar'])) ['foo', 'bar'] >>> list(yield_lines('foo\nbar')) ['foo', 'bar'] >>> list(yield_lines('\nfoo\n#bar\nbaz #comment')) ['foo', 'baz #comment'] >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n'])) ['foo', 'bar', 'baz', 'bing'] """ return itertools.chain.from_iterable(map(yield_lines, iterable)) @yield_lines.register(str) def _(text): return filter(_nonblank, map(str.strip, text.splitlines())) def drop_comment(line): """ Drop comments. >>> drop_comment('foo # bar') 'foo' A hash without a space may be in a URL. >>> drop_comment('http://example.com/foo#bar') 'http://example.com/foo#bar' """ return line.partition(' #')[0] def join_continuation(lines): r""" Join lines continued by a trailing backslash. >>> list(join_continuation(['foo \\', 'bar', 'baz'])) ['foobar', 'baz'] >>> list(join_continuation(['foo \\', 'bar', 'baz'])) ['foobar', 'baz'] >>> list(join_continuation(['foo \\', 'bar \\', 'baz'])) ['foobarbaz'] Not sure why, but... The character preceeding the backslash is also elided. >>> list(join_continuation(['goo\\', 'dly'])) ['godly'] A terrible idea, but... If no line is available to continue, suppress the lines. >>> list(join_continuation(['foo', 'bar\\', 'baz\\'])) ['foo'] """ lines = iter(lines) for item in lines: while item.endswith('\\'): try: item = item[:-2].strip() + next(lines) except StopIteration: return yield item ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/jaraco.context-4.3.0.dist-info/0000755000175100001730000000000014467657443025242 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco.context-4.3.0.dist-info/top_level.txt0000644000175100001730000000000714467657412027765 0ustar00runnerdockerjaraco ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/jaraco.functools-3.6.0.dist-info/0000755000175100001730000000000014467657443025574 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco.functools-3.6.0.dist-info/top_level.txt0000644000175100001730000000000714467657412030317 0ustar00runnerdockerjaraco ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/jaraco.text-3.7.0.dist-info/0000755000175100001730000000000014467657443024545 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/jaraco.text-3.7.0.dist-info/top_level.txt0000644000175100001730000000000714467657412027270 0ustar00runnerdockerjaraco ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4955482 setuptools-68.1.2/pkg_resources/_vendor/more_itertools/0000755000175100001730000000000014467657443023033 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/more_itertools/__init__.py0000644000175100001730000000022414467657412025136 0ustar00runnerdocker"""More routines for operating on iterables, beyond itertools""" from .more import * # noqa from .recipes import * # noqa __version__ = '9.1.0' ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/more_itertools/more.py0000755000175100001730000040750014467657412024354 0ustar00runnerdockerimport warnings from collections import Counter, defaultdict, deque, abc from collections.abc import Sequence from functools import partial, reduce, wraps from heapq import heapify, heapreplace, heappop from itertools import ( chain, compress, count, cycle, dropwhile, groupby, islice, repeat, starmap, takewhile, tee, zip_longest, ) from math import exp, factorial, floor, log from queue import Empty, Queue from random import random, randrange, uniform from operator import itemgetter, mul, sub, gt, lt, ge, le from sys import hexversion, maxsize from time import monotonic from .recipes import ( _marker, _zip_equal, UnequalIterablesError, consume, flatten, pairwise, powerset, take, unique_everseen, all_equal, ) __all__ = [ 'AbortThread', 'SequenceView', 'UnequalIterablesError', 'adjacent', 'all_unique', 'always_iterable', 'always_reversible', 'bucket', 'callback_iter', 'chunked', 'chunked_even', 'circular_shifts', 'collapse', 'combination_index', 'consecutive_groups', 'constrained_batches', 'consumer', 'count_cycle', 'countable', 'difference', 'distinct_combinations', 'distinct_permutations', 'distribute', 'divide', 'duplicates_everseen', 'duplicates_justseen', 'exactly_n', 'filter_except', 'first', 'gray_product', 'groupby_transform', 'ichunked', 'iequals', 'ilen', 'interleave', 'interleave_evenly', 'interleave_longest', 'intersperse', 'is_sorted', 'islice_extended', 'iterate', 'last', 'locate', 'longest_common_prefix', 'lstrip', 'make_decorator', 'map_except', 'map_if', 'map_reduce', 'mark_ends', 'minmax', 'nth_or_last', 'nth_permutation', 'nth_product', 'numeric_range', 'one', 'only', 'padded', 'partitions', 'peekable', 'permutation_index', 'product_index', 'raise_', 'repeat_each', 'repeat_last', 'replace', 'rlocate', 'rstrip', 'run_length', 'sample', 'seekable', 'set_partitions', 'side_effect', 'sliced', 'sort_together', 'split_after', 'split_at', 'split_before', 'split_into', 'split_when', 'spy', 'stagger', 'strip', 'strictly_n', 'substrings', 'substrings_indexes', 'time_limited', 'unique_in_window', 'unique_to_each', 'unzip', 'value_chain', 'windowed', 'windowed_complete', 'with_iter', 'zip_broadcast', 'zip_equal', 'zip_offset', ] def chunked(iterable, n, strict=False): """Break *iterable* into lists of length *n*: >>> list(chunked([1, 2, 3, 4, 5, 6], 3)) [[1, 2, 3], [4, 5, 6]] By the default, the last yielded list will have fewer than *n* elements if the length of *iterable* is not divisible by *n*: >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3)) [[1, 2, 3], [4, 5, 6], [7, 8]] To use a fill-in value instead, see the :func:`grouper` recipe. If the length of *iterable* is not divisible by *n* and *strict* is ``True``, then ``ValueError`` will be raised before the last list is yielded. """ iterator = iter(partial(take, n, iter(iterable)), []) if strict: if n is None: raise ValueError('n must not be None when using strict mode.') def ret(): for chunk in iterator: if len(chunk) != n: raise ValueError('iterable is not divisible by n.') yield chunk return iter(ret()) else: return iterator def first(iterable, default=_marker): """Return the first item of *iterable*, or *default* if *iterable* is empty. >>> first([0, 1, 2, 3]) 0 >>> first([], 'some default') 'some default' If *default* is not provided and there are no items in the iterable, raise ``ValueError``. :func:`first` is useful when you have a generator of expensive-to-retrieve values and want any arbitrary one. It is marginally shorter than ``next(iter(iterable), default)``. """ try: return next(iter(iterable)) except StopIteration as e: if default is _marker: raise ValueError( 'first() was called on an empty iterable, and no ' 'default value was provided.' ) from e return default def last(iterable, default=_marker): """Return the last item of *iterable*, or *default* if *iterable* is empty. >>> last([0, 1, 2, 3]) 3 >>> last([], 'some default') 'some default' If *default* is not provided and there are no items in the iterable, raise ``ValueError``. """ try: if isinstance(iterable, Sequence): return iterable[-1] # Work around https://bugs.python.org/issue38525 elif hasattr(iterable, '__reversed__') and (hexversion != 0x030800F0): return next(reversed(iterable)) else: return deque(iterable, maxlen=1)[-1] except (IndexError, TypeError, StopIteration): if default is _marker: raise ValueError( 'last() was called on an empty iterable, and no default was ' 'provided.' ) return default def nth_or_last(iterable, n, default=_marker): """Return the nth or the last item of *iterable*, or *default* if *iterable* is empty. >>> nth_or_last([0, 1, 2, 3], 2) 2 >>> nth_or_last([0, 1], 2) 1 >>> nth_or_last([], 0, 'some default') 'some default' If *default* is not provided and there are no items in the iterable, raise ``ValueError``. """ return last(islice(iterable, n + 1), default=default) class peekable: """Wrap an iterator to allow lookahead and prepending elements. Call :meth:`peek` on the result to get the value that will be returned by :func:`next`. This won't advance the iterator: >>> p = peekable(['a', 'b']) >>> p.peek() 'a' >>> next(p) 'a' Pass :meth:`peek` a default value to return that instead of raising ``StopIteration`` when the iterator is exhausted. >>> p = peekable([]) >>> p.peek('hi') 'hi' peekables also offer a :meth:`prepend` method, which "inserts" items at the head of the iterable: >>> p = peekable([1, 2, 3]) >>> p.prepend(10, 11, 12) >>> next(p) 10 >>> p.peek() 11 >>> list(p) [11, 12, 1, 2, 3] peekables can be indexed. Index 0 is the item that will be returned by :func:`next`, index 1 is the item after that, and so on: The values up to the given index will be cached. >>> p = peekable(['a', 'b', 'c', 'd']) >>> p[0] 'a' >>> p[1] 'b' >>> next(p) 'a' Negative indexes are supported, but be aware that they will cache the remaining items in the source iterator, which may require significant storage. To check whether a peekable is exhausted, check its truth value: >>> p = peekable(['a', 'b']) >>> if p: # peekable has items ... list(p) ['a', 'b'] >>> if not p: # peekable is exhausted ... list(p) [] """ def __init__(self, iterable): self._it = iter(iterable) self._cache = deque() def __iter__(self): return self def __bool__(self): try: self.peek() except StopIteration: return False return True def peek(self, default=_marker): """Return the item that will be next returned from ``next()``. Return ``default`` if there are no items left. If ``default`` is not provided, raise ``StopIteration``. """ if not self._cache: try: self._cache.append(next(self._it)) except StopIteration: if default is _marker: raise return default return self._cache[0] def prepend(self, *items): """Stack up items to be the next ones returned from ``next()`` or ``self.peek()``. The items will be returned in first in, first out order:: >>> p = peekable([1, 2, 3]) >>> p.prepend(10, 11, 12) >>> next(p) 10 >>> list(p) [11, 12, 1, 2, 3] It is possible, by prepending items, to "resurrect" a peekable that previously raised ``StopIteration``. >>> p = peekable([]) >>> next(p) Traceback (most recent call last): ... StopIteration >>> p.prepend(1) >>> next(p) 1 >>> next(p) Traceback (most recent call last): ... StopIteration """ self._cache.extendleft(reversed(items)) def __next__(self): if self._cache: return self._cache.popleft() return next(self._it) def _get_slice(self, index): # Normalize the slice's arguments step = 1 if (index.step is None) else index.step if step > 0: start = 0 if (index.start is None) else index.start stop = maxsize if (index.stop is None) else index.stop elif step < 0: start = -1 if (index.start is None) else index.start stop = (-maxsize - 1) if (index.stop is None) else index.stop else: raise ValueError('slice step cannot be zero') # If either the start or stop index is negative, we'll need to cache # the rest of the iterable in order to slice from the right side. if (start < 0) or (stop < 0): self._cache.extend(self._it) # Otherwise we'll need to find the rightmost index and cache to that # point. else: n = min(max(start, stop) + 1, maxsize) cache_len = len(self._cache) if n >= cache_len: self._cache.extend(islice(self._it, n - cache_len)) return list(self._cache)[index] def __getitem__(self, index): if isinstance(index, slice): return self._get_slice(index) cache_len = len(self._cache) if index < 0: self._cache.extend(self._it) elif index >= cache_len: self._cache.extend(islice(self._it, index + 1 - cache_len)) return self._cache[index] def consumer(func): """Decorator that automatically advances a PEP-342-style "reverse iterator" to its first yield point so you don't have to call ``next()`` on it manually. >>> @consumer ... def tally(): ... i = 0 ... while True: ... print('Thing number %s is %s.' % (i, (yield))) ... i += 1 ... >>> t = tally() >>> t.send('red') Thing number 0 is red. >>> t.send('fish') Thing number 1 is fish. Without the decorator, you would have to call ``next(t)`` before ``t.send()`` could be used. """ @wraps(func) def wrapper(*args, **kwargs): gen = func(*args, **kwargs) next(gen) return gen return wrapper def ilen(iterable): """Return the number of items in *iterable*. >>> ilen(x for x in range(1000000) if x % 3 == 0) 333334 This consumes the iterable, so handle with care. """ # This approach was selected because benchmarks showed it's likely the # fastest of the known implementations at the time of writing. # See GitHub tracker: #236, #230. counter = count() deque(zip(iterable, counter), maxlen=0) return next(counter) def iterate(func, start): """Return ``start``, ``func(start)``, ``func(func(start))``, ... >>> from itertools import islice >>> list(islice(iterate(lambda x: 2*x, 1), 10)) [1, 2, 4, 8, 16, 32, 64, 128, 256, 512] """ while True: yield start start = func(start) def with_iter(context_manager): """Wrap an iterable in a ``with`` statement, so it closes once exhausted. For example, this will close the file when the iterator is exhausted:: upper_lines = (line.upper() for line in with_iter(open('foo'))) Any context manager which returns an iterable is a candidate for ``with_iter``. """ with context_manager as iterable: yield from iterable def one(iterable, too_short=None, too_long=None): """Return the first item from *iterable*, which is expected to contain only that item. Raise an exception if *iterable* is empty or has more than one item. :func:`one` is useful for ensuring that an iterable contains only one item. For example, it can be used to retrieve the result of a database query that is expected to return a single row. If *iterable* is empty, ``ValueError`` will be raised. You may specify a different exception with the *too_short* keyword: >>> it = [] >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: too many items in iterable (expected 1)' >>> too_short = IndexError('too few items') >>> one(it, too_short=too_short) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... IndexError: too few items Similarly, if *iterable* contains more than one item, ``ValueError`` will be raised. You may specify a different exception with the *too_long* keyword: >>> it = ['too', 'many'] >>> one(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: Expected exactly one item in iterable, but got 'too', 'many', and perhaps more. >>> too_long = RuntimeError >>> one(it, too_long=too_long) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... RuntimeError Note that :func:`one` attempts to advance *iterable* twice to ensure there is only one item. See :func:`spy` or :func:`peekable` to check iterable contents less destructively. """ it = iter(iterable) try: first_value = next(it) except StopIteration as e: raise ( too_short or ValueError('too few items in iterable (expected 1)') ) from e try: second_value = next(it) except StopIteration: pass else: msg = ( 'Expected exactly one item in iterable, but got {!r}, {!r}, ' 'and perhaps more.'.format(first_value, second_value) ) raise too_long or ValueError(msg) return first_value def raise_(exception, *args): raise exception(*args) def strictly_n(iterable, n, too_short=None, too_long=None): """Validate that *iterable* has exactly *n* items and return them if it does. If it has fewer than *n* items, call function *too_short* with those items. If it has more than *n* items, call function *too_long* with the first ``n + 1`` items. >>> iterable = ['a', 'b', 'c', 'd'] >>> n = 4 >>> list(strictly_n(iterable, n)) ['a', 'b', 'c', 'd'] By default, *too_short* and *too_long* are functions that raise ``ValueError``. >>> list(strictly_n('ab', 3)) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: too few items in iterable (got 2) >>> list(strictly_n('abc', 2)) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: too many items in iterable (got at least 3) You can instead supply functions that do something else. *too_short* will be called with the number of items in *iterable*. *too_long* will be called with `n + 1`. >>> def too_short(item_count): ... raise RuntimeError >>> it = strictly_n('abcd', 6, too_short=too_short) >>> list(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... RuntimeError >>> def too_long(item_count): ... print('The boss is going to hear about this') >>> it = strictly_n('abcdef', 4, too_long=too_long) >>> list(it) The boss is going to hear about this ['a', 'b', 'c', 'd'] """ if too_short is None: too_short = lambda item_count: raise_( ValueError, 'Too few items in iterable (got {})'.format(item_count), ) if too_long is None: too_long = lambda item_count: raise_( ValueError, 'Too many items in iterable (got at least {})'.format(item_count), ) it = iter(iterable) for i in range(n): try: item = next(it) except StopIteration: too_short(i) return else: yield item try: next(it) except StopIteration: pass else: too_long(n + 1) def distinct_permutations(iterable, r=None): """Yield successive distinct permutations of the elements in *iterable*. >>> sorted(distinct_permutations([1, 0, 1])) [(0, 1, 1), (1, 0, 1), (1, 1, 0)] Equivalent to ``set(permutations(iterable))``, except duplicates are not generated and thrown away. For larger input sequences this is much more efficient. Duplicate permutations arise when there are duplicated elements in the input iterable. The number of items returned is `n! / (x_1! * x_2! * ... * x_n!)`, where `n` is the total number of items input, and each `x_i` is the count of a distinct item in the input sequence. If *r* is given, only the *r*-length permutations are yielded. >>> sorted(distinct_permutations([1, 0, 1], r=2)) [(0, 1), (1, 0), (1, 1)] >>> sorted(distinct_permutations(range(3), r=2)) [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)] """ # Algorithm: https://w.wiki/Qai def _full(A): while True: # Yield the permutation we have yield tuple(A) # Find the largest index i such that A[i] < A[i + 1] for i in range(size - 2, -1, -1): if A[i] < A[i + 1]: break # If no such index exists, this permutation is the last one else: return # Find the largest index j greater than j such that A[i] < A[j] for j in range(size - 1, i, -1): if A[i] < A[j]: break # Swap the value of A[i] with that of A[j], then reverse the # sequence from A[i + 1] to form the new permutation A[i], A[j] = A[j], A[i] A[i + 1 :] = A[: i - size : -1] # A[i + 1:][::-1] # Algorithm: modified from the above def _partial(A, r): # Split A into the first r items and the last r items head, tail = A[:r], A[r:] right_head_indexes = range(r - 1, -1, -1) left_tail_indexes = range(len(tail)) while True: # Yield the permutation we have yield tuple(head) # Starting from the right, find the first index of the head with # value smaller than the maximum value of the tail - call it i. pivot = tail[-1] for i in right_head_indexes: if head[i] < pivot: break pivot = head[i] else: return # Starting from the left, find the first value of the tail # with a value greater than head[i] and swap. for j in left_tail_indexes: if tail[j] > head[i]: head[i], tail[j] = tail[j], head[i] break # If we didn't find one, start from the right and find the first # index of the head with a value greater than head[i] and swap. else: for j in right_head_indexes: if head[j] > head[i]: head[i], head[j] = head[j], head[i] break # Reverse head[i + 1:] and swap it with tail[:r - (i + 1)] tail += head[: i - r : -1] # head[i + 1:][::-1] i += 1 head[i:], tail[:] = tail[: r - i], tail[r - i :] items = sorted(iterable) size = len(items) if r is None: r = size if 0 < r <= size: return _full(items) if (r == size) else _partial(items, r) return iter(() if r else ((),)) def intersperse(e, iterable, n=1): """Intersperse filler element *e* among the items in *iterable*, leaving *n* items between each filler element. >>> list(intersperse('!', [1, 2, 3, 4, 5])) [1, '!', 2, '!', 3, '!', 4, '!', 5] >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2)) [1, 2, None, 3, 4, None, 5] """ if n == 0: raise ValueError('n must be > 0') elif n == 1: # interleave(repeat(e), iterable) -> e, x_0, e, x_1, e, x_2... # islice(..., 1, None) -> x_0, e, x_1, e, x_2... return islice(interleave(repeat(e), iterable), 1, None) else: # interleave(filler, chunks) -> [e], [x_0, x_1], [e], [x_2, x_3]... # islice(..., 1, None) -> [x_0, x_1], [e], [x_2, x_3]... # flatten(...) -> x_0, x_1, e, x_2, x_3... filler = repeat([e]) chunks = chunked(iterable, n) return flatten(islice(interleave(filler, chunks), 1, None)) def unique_to_each(*iterables): """Return the elements from each of the input iterables that aren't in the other input iterables. For example, suppose you have a set of packages, each with a set of dependencies:: {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}} If you remove one package, which dependencies can also be removed? If ``pkg_1`` is removed, then ``A`` is no longer necessary - it is not associated with ``pkg_2`` or ``pkg_3``. Similarly, ``C`` is only needed for ``pkg_2``, and ``D`` is only needed for ``pkg_3``:: >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'}) [['A'], ['C'], ['D']] If there are duplicates in one input iterable that aren't in the others they will be duplicated in the output. Input order is preserved:: >>> unique_to_each("mississippi", "missouri") [['p', 'p'], ['o', 'u', 'r']] It is assumed that the elements of each iterable are hashable. """ pool = [list(it) for it in iterables] counts = Counter(chain.from_iterable(map(set, pool))) uniques = {element for element in counts if counts[element] == 1} return [list(filter(uniques.__contains__, it)) for it in pool] def windowed(seq, n, fillvalue=None, step=1): """Return a sliding window of width *n* over the given iterable. >>> all_windows = windowed([1, 2, 3, 4, 5], 3) >>> list(all_windows) [(1, 2, 3), (2, 3, 4), (3, 4, 5)] When the window is larger than the iterable, *fillvalue* is used in place of missing values: >>> list(windowed([1, 2, 3], 4)) [(1, 2, 3, None)] Each window will advance in increments of *step*: >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2)) [(1, 2, 3), (3, 4, 5), (5, 6, '!')] To slide into the iterable's items, use :func:`chain` to add filler items to the left: >>> iterable = [1, 2, 3, 4] >>> n = 3 >>> padding = [None] * (n - 1) >>> list(windowed(chain(padding, iterable), 3)) [(None, None, 1), (None, 1, 2), (1, 2, 3), (2, 3, 4)] """ if n < 0: raise ValueError('n must be >= 0') if n == 0: yield tuple() return if step < 1: raise ValueError('step must be >= 1') window = deque(maxlen=n) i = n for _ in map(window.append, seq): i -= 1 if not i: i = step yield tuple(window) size = len(window) if size == 0: return elif size < n: yield tuple(chain(window, repeat(fillvalue, n - size))) elif 0 < i < min(step, n): window += (fillvalue,) * i yield tuple(window) def substrings(iterable): """Yield all of the substrings of *iterable*. >>> [''.join(s) for s in substrings('more')] ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more'] Note that non-string iterables can also be subdivided. >>> list(substrings([0, 1, 2])) [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)] """ # The length-1 substrings seq = [] for item in iter(iterable): seq.append(item) yield (item,) seq = tuple(seq) item_count = len(seq) # And the rest for n in range(2, item_count + 1): for i in range(item_count - n + 1): yield seq[i : i + n] def substrings_indexes(seq, reverse=False): """Yield all substrings and their positions in *seq* The items yielded will be a tuple of the form ``(substr, i, j)``, where ``substr == seq[i:j]``. This function only works for iterables that support slicing, such as ``str`` objects. >>> for item in substrings_indexes('more'): ... print(item) ('m', 0, 1) ('o', 1, 2) ('r', 2, 3) ('e', 3, 4) ('mo', 0, 2) ('or', 1, 3) ('re', 2, 4) ('mor', 0, 3) ('ore', 1, 4) ('more', 0, 4) Set *reverse* to ``True`` to yield the same items in the opposite order. """ r = range(1, len(seq) + 1) if reverse: r = reversed(r) return ( (seq[i : i + L], i, i + L) for L in r for i in range(len(seq) - L + 1) ) class bucket: """Wrap *iterable* and return an object that buckets it iterable into child iterables based on a *key* function. >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3'] >>> s = bucket(iterable, key=lambda x: x[0]) # Bucket by 1st character >>> sorted(list(s)) # Get the keys ['a', 'b', 'c'] >>> a_iterable = s['a'] >>> next(a_iterable) 'a1' >>> next(a_iterable) 'a2' >>> list(s['b']) ['b1', 'b2', 'b3'] The original iterable will be advanced and its items will be cached until they are used by the child iterables. This may require significant storage. By default, attempting to select a bucket to which no items belong will exhaust the iterable and cache all values. If you specify a *validator* function, selected buckets will instead be checked against it. >>> from itertools import count >>> it = count(1, 2) # Infinite sequence of odd numbers >>> key = lambda x: x % 10 # Bucket by last digit >>> validator = lambda x: x in {1, 3, 5, 7, 9} # Odd digits only >>> s = bucket(it, key=key, validator=validator) >>> 2 in s False >>> list(s[2]) [] """ def __init__(self, iterable, key, validator=None): self._it = iter(iterable) self._key = key self._cache = defaultdict(deque) self._validator = validator or (lambda x: True) def __contains__(self, value): if not self._validator(value): return False try: item = next(self[value]) except StopIteration: return False else: self._cache[value].appendleft(item) return True def _get_values(self, value): """ Helper to yield items from the parent iterator that match *value*. Items that don't match are stored in the local cache as they are encountered. """ while True: # If we've cached some items that match the target value, emit # the first one and evict it from the cache. if self._cache[value]: yield self._cache[value].popleft() # Otherwise we need to advance the parent iterator to search for # a matching item, caching the rest. else: while True: try: item = next(self._it) except StopIteration: return item_value = self._key(item) if item_value == value: yield item break elif self._validator(item_value): self._cache[item_value].append(item) def __iter__(self): for item in self._it: item_value = self._key(item) if self._validator(item_value): self._cache[item_value].append(item) yield from self._cache.keys() def __getitem__(self, value): if not self._validator(value): return iter(()) return self._get_values(value) def spy(iterable, n=1): """Return a 2-tuple with a list containing the first *n* elements of *iterable*, and an iterator with the same items as *iterable*. This allows you to "look ahead" at the items in the iterable without advancing it. There is one item in the list by default: >>> iterable = 'abcdefg' >>> head, iterable = spy(iterable) >>> head ['a'] >>> list(iterable) ['a', 'b', 'c', 'd', 'e', 'f', 'g'] You may use unpacking to retrieve items instead of lists: >>> (head,), iterable = spy('abcdefg') >>> head 'a' >>> (first, second), iterable = spy('abcdefg', 2) >>> first 'a' >>> second 'b' The number of items requested can be larger than the number of items in the iterable: >>> iterable = [1, 2, 3, 4, 5] >>> head, iterable = spy(iterable, 10) >>> head [1, 2, 3, 4, 5] >>> list(iterable) [1, 2, 3, 4, 5] """ it = iter(iterable) head = take(n, it) return head.copy(), chain(head, it) def interleave(*iterables): """Return a new iterable yielding from each iterable in turn, until the shortest is exhausted. >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8])) [1, 4, 6, 2, 5, 7] For a version that doesn't terminate after the shortest iterable is exhausted, see :func:`interleave_longest`. """ return chain.from_iterable(zip(*iterables)) def interleave_longest(*iterables): """Return a new iterable yielding from each iterable in turn, skipping any that are exhausted. >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8])) [1, 4, 6, 2, 5, 7, 3, 8] This function produces the same output as :func:`roundrobin`, but may perform better for some inputs (in particular when the number of iterables is large). """ i = chain.from_iterable(zip_longest(*iterables, fillvalue=_marker)) return (x for x in i if x is not _marker) def interleave_evenly(iterables, lengths=None): """ Interleave multiple iterables so that their elements are evenly distributed throughout the output sequence. >>> iterables = [1, 2, 3, 4, 5], ['a', 'b'] >>> list(interleave_evenly(iterables)) [1, 2, 'a', 3, 4, 'b', 5] >>> iterables = [[1, 2, 3], [4, 5], [6, 7, 8]] >>> list(interleave_evenly(iterables)) [1, 6, 4, 2, 7, 3, 8, 5] This function requires iterables of known length. Iterables without ``__len__()`` can be used by manually specifying lengths with *lengths*: >>> from itertools import combinations, repeat >>> iterables = [combinations(range(4), 2), ['a', 'b', 'c']] >>> lengths = [4 * (4 - 1) // 2, 3] >>> list(interleave_evenly(iterables, lengths=lengths)) [(0, 1), (0, 2), 'a', (0, 3), (1, 2), 'b', (1, 3), (2, 3), 'c'] Based on Bresenham's algorithm. """ if lengths is None: try: lengths = [len(it) for it in iterables] except TypeError: raise ValueError( 'Iterable lengths could not be determined automatically. ' 'Specify them with the lengths keyword.' ) elif len(iterables) != len(lengths): raise ValueError('Mismatching number of iterables and lengths.') dims = len(lengths) # sort iterables by length, descending lengths_permute = sorted( range(dims), key=lambda i: lengths[i], reverse=True ) lengths_desc = [lengths[i] for i in lengths_permute] iters_desc = [iter(iterables[i]) for i in lengths_permute] # the longest iterable is the primary one (Bresenham: the longest # distance along an axis) delta_primary, deltas_secondary = lengths_desc[0], lengths_desc[1:] iter_primary, iters_secondary = iters_desc[0], iters_desc[1:] errors = [delta_primary // dims] * len(deltas_secondary) to_yield = sum(lengths) while to_yield: yield next(iter_primary) to_yield -= 1 # update errors for each secondary iterable errors = [e - delta for e, delta in zip(errors, deltas_secondary)] # those iterables for which the error is negative are yielded # ("diagonal step" in Bresenham) for i, e in enumerate(errors): if e < 0: yield next(iters_secondary[i]) to_yield -= 1 errors[i] += delta_primary def collapse(iterable, base_type=None, levels=None): """Flatten an iterable with multiple levels of nesting (e.g., a list of lists of tuples) into non-iterable types. >>> iterable = [(1, 2), ([3, 4], [[5], [6]])] >>> list(collapse(iterable)) [1, 2, 3, 4, 5, 6] Binary and text strings are not considered iterable and will not be collapsed. To avoid collapsing other types, specify *base_type*: >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']] >>> list(collapse(iterable, base_type=tuple)) ['ab', ('cd', 'ef'), 'gh', 'ij'] Specify *levels* to stop flattening after a certain level: >>> iterable = [('a', ['b']), ('c', ['d'])] >>> list(collapse(iterable)) # Fully flattened ['a', 'b', 'c', 'd'] >>> list(collapse(iterable, levels=1)) # Only one level flattened ['a', ['b'], 'c', ['d']] """ def walk(node, level): if ( ((levels is not None) and (level > levels)) or isinstance(node, (str, bytes)) or ((base_type is not None) and isinstance(node, base_type)) ): yield node return try: tree = iter(node) except TypeError: yield node return else: for child in tree: yield from walk(child, level + 1) yield from walk(iterable, 0) def side_effect(func, iterable, chunk_size=None, before=None, after=None): """Invoke *func* on each item in *iterable* (or on each *chunk_size* group of items) before yielding the item. `func` must be a function that takes a single argument. Its return value will be discarded. *before* and *after* are optional functions that take no arguments. They will be executed before iteration starts and after it ends, respectively. `side_effect` can be used for logging, updating progress bars, or anything that is not functionally "pure." Emitting a status message: >>> from more_itertools import consume >>> func = lambda item: print('Received {}'.format(item)) >>> consume(side_effect(func, range(2))) Received 0 Received 1 Operating on chunks of items: >>> pair_sums = [] >>> func = lambda chunk: pair_sums.append(sum(chunk)) >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2)) [0, 1, 2, 3, 4, 5] >>> list(pair_sums) [1, 5, 9] Writing to a file-like object: >>> from io import StringIO >>> from more_itertools import consume >>> f = StringIO() >>> func = lambda x: print(x, file=f) >>> before = lambda: print(u'HEADER', file=f) >>> after = f.close >>> it = [u'a', u'b', u'c'] >>> consume(side_effect(func, it, before=before, after=after)) >>> f.closed True """ try: if before is not None: before() if chunk_size is None: for item in iterable: func(item) yield item else: for chunk in chunked(iterable, chunk_size): func(chunk) yield from chunk finally: if after is not None: after() def sliced(seq, n, strict=False): """Yield slices of length *n* from the sequence *seq*. >>> list(sliced((1, 2, 3, 4, 5, 6), 3)) [(1, 2, 3), (4, 5, 6)] By the default, the last yielded slice will have fewer than *n* elements if the length of *seq* is not divisible by *n*: >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3)) [(1, 2, 3), (4, 5, 6), (7, 8)] If the length of *seq* is not divisible by *n* and *strict* is ``True``, then ``ValueError`` will be raised before the last slice is yielded. This function will only work for iterables that support slicing. For non-sliceable iterables, see :func:`chunked`. """ iterator = takewhile(len, (seq[i : i + n] for i in count(0, n))) if strict: def ret(): for _slice in iterator: if len(_slice) != n: raise ValueError("seq is not divisible by n.") yield _slice return iter(ret()) else: return iterator def split_at(iterable, pred, maxsplit=-1, keep_separator=False): """Yield lists of items from *iterable*, where each list is delimited by an item where callable *pred* returns ``True``. >>> list(split_at('abcdcba', lambda x: x == 'b')) [['a'], ['c', 'd', 'c'], ['a']] >>> list(split_at(range(10), lambda n: n % 2 == 1)) [[0], [2], [4], [6], [8], []] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_at(range(10), lambda n: n % 2 == 1, maxsplit=2)) [[0], [2], [4, 5, 6, 7, 8, 9]] By default, the delimiting items are not included in the output. To include them, set *keep_separator* to ``True``. >>> list(split_at('abcdcba', lambda x: x == 'b', keep_separator=True)) [['a'], ['b'], ['c', 'd', 'c'], ['b'], ['a']] """ if maxsplit == 0: yield list(iterable) return buf = [] it = iter(iterable) for item in it: if pred(item): yield buf if keep_separator: yield [item] if maxsplit == 1: yield list(it) return buf = [] maxsplit -= 1 else: buf.append(item) yield buf def split_before(iterable, pred, maxsplit=-1): """Yield lists of items from *iterable*, where each list ends just before an item for which callable *pred* returns ``True``: >>> list(split_before('OneTwo', lambda s: s.isupper())) [['O', 'n', 'e'], ['T', 'w', 'o']] >>> list(split_before(range(10), lambda n: n % 3 == 0)) [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_before(range(10), lambda n: n % 3 == 0, maxsplit=2)) [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]] """ if maxsplit == 0: yield list(iterable) return buf = [] it = iter(iterable) for item in it: if pred(item) and buf: yield buf if maxsplit == 1: yield [item] + list(it) return buf = [] maxsplit -= 1 buf.append(item) if buf: yield buf def split_after(iterable, pred, maxsplit=-1): """Yield lists of items from *iterable*, where each list ends with an item where callable *pred* returns ``True``: >>> list(split_after('one1two2', lambda s: s.isdigit())) [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']] >>> list(split_after(range(10), lambda n: n % 3 == 0)) [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_after(range(10), lambda n: n % 3 == 0, maxsplit=2)) [[0], [1, 2, 3], [4, 5, 6, 7, 8, 9]] """ if maxsplit == 0: yield list(iterable) return buf = [] it = iter(iterable) for item in it: buf.append(item) if pred(item) and buf: yield buf if maxsplit == 1: buf = list(it) if buf: yield buf return buf = [] maxsplit -= 1 if buf: yield buf def split_when(iterable, pred, maxsplit=-1): """Split *iterable* into pieces based on the output of *pred*. *pred* should be a function that takes successive pairs of items and returns ``True`` if the iterable should be split in between them. For example, to find runs of increasing numbers, split the iterable when element ``i`` is larger than element ``i + 1``: >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], lambda x, y: x > y)) [[1, 2, 3, 3], [2, 5], [2, 4], [2]] At most *maxsplit* splits are done. If *maxsplit* is not specified or -1, then there is no limit on the number of splits: >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], ... lambda x, y: x > y, maxsplit=2)) [[1, 2, 3, 3], [2, 5], [2, 4, 2]] """ if maxsplit == 0: yield list(iterable) return it = iter(iterable) try: cur_item = next(it) except StopIteration: return buf = [cur_item] for next_item in it: if pred(cur_item, next_item): yield buf if maxsplit == 1: yield [next_item] + list(it) return buf = [] maxsplit -= 1 buf.append(next_item) cur_item = next_item yield buf def split_into(iterable, sizes): """Yield a list of sequential items from *iterable* of length 'n' for each integer 'n' in *sizes*. >>> list(split_into([1,2,3,4,5,6], [1,2,3])) [[1], [2, 3], [4, 5, 6]] If the sum of *sizes* is smaller than the length of *iterable*, then the remaining items of *iterable* will not be returned. >>> list(split_into([1,2,3,4,5,6], [2,3])) [[1, 2], [3, 4, 5]] If the sum of *sizes* is larger than the length of *iterable*, fewer items will be returned in the iteration that overruns *iterable* and further lists will be empty: >>> list(split_into([1,2,3,4], [1,2,3,4])) [[1], [2, 3], [4], []] When a ``None`` object is encountered in *sizes*, the returned list will contain items up to the end of *iterable* the same way that itertools.slice does: >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None])) [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]] :func:`split_into` can be useful for grouping a series of items where the sizes of the groups are not uniform. An example would be where in a row from a table, multiple columns represent elements of the same feature (e.g. a point represented by x,y,z) but, the format is not the same for all columns. """ # convert the iterable argument into an iterator so its contents can # be consumed by islice in case it is a generator it = iter(iterable) for size in sizes: if size is None: yield list(it) return else: yield list(islice(it, size)) def padded(iterable, fillvalue=None, n=None, next_multiple=False): """Yield the elements from *iterable*, followed by *fillvalue*, such that at least *n* items are emitted. >>> list(padded([1, 2, 3], '?', 5)) [1, 2, 3, '?', '?'] If *next_multiple* is ``True``, *fillvalue* will be emitted until the number of items emitted is a multiple of *n*:: >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True)) [1, 2, 3, 4, None, None] If *n* is ``None``, *fillvalue* will be emitted indefinitely. """ it = iter(iterable) if n is None: yield from chain(it, repeat(fillvalue)) elif n < 1: raise ValueError('n must be at least 1') else: item_count = 0 for item in it: yield item item_count += 1 remaining = (n - item_count) % n if next_multiple else n - item_count for _ in range(remaining): yield fillvalue def repeat_each(iterable, n=2): """Repeat each element in *iterable* *n* times. >>> list(repeat_each('ABC', 3)) ['A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'C'] """ return chain.from_iterable(map(repeat, iterable, repeat(n))) def repeat_last(iterable, default=None): """After the *iterable* is exhausted, keep yielding its last element. >>> list(islice(repeat_last(range(3)), 5)) [0, 1, 2, 2, 2] If the iterable is empty, yield *default* forever:: >>> list(islice(repeat_last(range(0), 42), 5)) [42, 42, 42, 42, 42] """ item = _marker for item in iterable: yield item final = default if item is _marker else item yield from repeat(final) def distribute(n, iterable): """Distribute the items from *iterable* among *n* smaller iterables. >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6]) >>> list(group_1) [1, 3, 5] >>> list(group_2) [2, 4, 6] If the length of *iterable* is not evenly divisible by *n*, then the length of the returned iterables will not be identical: >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7]) >>> [list(c) for c in children] [[1, 4, 7], [2, 5], [3, 6]] If the length of *iterable* is smaller than *n*, then the last returned iterables will be empty: >>> children = distribute(5, [1, 2, 3]) >>> [list(c) for c in children] [[1], [2], [3], [], []] This function uses :func:`itertools.tee` and may require significant storage. If you need the order items in the smaller iterables to match the original iterable, see :func:`divide`. """ if n < 1: raise ValueError('n must be at least 1') children = tee(iterable, n) return [islice(it, index, None, n) for index, it in enumerate(children)] def stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None): """Yield tuples whose elements are offset from *iterable*. The amount by which the `i`-th item in each tuple is offset is given by the `i`-th item in *offsets*. >>> list(stagger([0, 1, 2, 3])) [(None, 0, 1), (0, 1, 2), (1, 2, 3)] >>> list(stagger(range(8), offsets=(0, 2, 4))) [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)] By default, the sequence will end when the final element of a tuple is the last item in the iterable. To continue until the first element of a tuple is the last item in the iterable, set *longest* to ``True``:: >>> list(stagger([0, 1, 2, 3], longest=True)) [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)] By default, ``None`` will be used to replace offsets beyond the end of the sequence. Specify *fillvalue* to use some other value. """ children = tee(iterable, len(offsets)) return zip_offset( *children, offsets=offsets, longest=longest, fillvalue=fillvalue ) def zip_equal(*iterables): """``zip`` the input *iterables* together, but raise ``UnequalIterablesError`` if they aren't all the same length. >>> it_1 = range(3) >>> it_2 = iter('abc') >>> list(zip_equal(it_1, it_2)) [(0, 'a'), (1, 'b'), (2, 'c')] >>> it_1 = range(3) >>> it_2 = iter('abcd') >>> list(zip_equal(it_1, it_2)) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... more_itertools.more.UnequalIterablesError: Iterables have different lengths """ if hexversion >= 0x30A00A6: warnings.warn( ( 'zip_equal will be removed in a future version of ' 'more-itertools. Use the builtin zip function with ' 'strict=True instead.' ), DeprecationWarning, ) return _zip_equal(*iterables) def zip_offset(*iterables, offsets, longest=False, fillvalue=None): """``zip`` the input *iterables* together, but offset the `i`-th iterable by the `i`-th item in *offsets*. >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1))) [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')] This can be used as a lightweight alternative to SciPy or pandas to analyze data sets in which some series have a lead or lag relationship. By default, the sequence will end when the shortest iterable is exhausted. To continue until the longest iterable is exhausted, set *longest* to ``True``. >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True)) [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')] By default, ``None`` will be used to replace offsets beyond the end of the sequence. Specify *fillvalue* to use some other value. """ if len(iterables) != len(offsets): raise ValueError("Number of iterables and offsets didn't match") staggered = [] for it, n in zip(iterables, offsets): if n < 0: staggered.append(chain(repeat(fillvalue, -n), it)) elif n > 0: staggered.append(islice(it, n, None)) else: staggered.append(it) if longest: return zip_longest(*staggered, fillvalue=fillvalue) return zip(*staggered) def sort_together(iterables, key_list=(0,), key=None, reverse=False): """Return the input iterables sorted together, with *key_list* as the priority for sorting. All iterables are trimmed to the length of the shortest one. This can be used like the sorting function in a spreadsheet. If each iterable represents a column of data, the key list determines which columns are used for sorting. By default, all iterables are sorted using the ``0``-th iterable:: >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')] >>> sort_together(iterables) [(1, 2, 3, 4), ('d', 'c', 'b', 'a')] Set a different key list to sort according to another iterable. Specifying multiple keys dictates how ties are broken:: >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')] >>> sort_together(iterables, key_list=(1, 2)) [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')] To sort by a function of the elements of the iterable, pass a *key* function. Its arguments are the elements of the iterables corresponding to the key list:: >>> names = ('a', 'b', 'c') >>> lengths = (1, 2, 3) >>> widths = (5, 2, 1) >>> def area(length, width): ... return length * width >>> sort_together([names, lengths, widths], key_list=(1, 2), key=area) [('c', 'b', 'a'), (3, 2, 1), (1, 2, 5)] Set *reverse* to ``True`` to sort in descending order. >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True) [(3, 2, 1), ('a', 'b', 'c')] """ if key is None: # if there is no key function, the key argument to sorted is an # itemgetter key_argument = itemgetter(*key_list) else: # if there is a key function, call it with the items at the offsets # specified by the key function as arguments key_list = list(key_list) if len(key_list) == 1: # if key_list contains a single item, pass the item at that offset # as the only argument to the key function key_offset = key_list[0] key_argument = lambda zipped_items: key(zipped_items[key_offset]) else: # if key_list contains multiple items, use itemgetter to return a # tuple of items, which we pass as *args to the key function get_key_items = itemgetter(*key_list) key_argument = lambda zipped_items: key( *get_key_items(zipped_items) ) return list( zip(*sorted(zip(*iterables), key=key_argument, reverse=reverse)) ) def unzip(iterable): """The inverse of :func:`zip`, this function disaggregates the elements of the zipped *iterable*. The ``i``-th iterable contains the ``i``-th element from each element of the zipped iterable. The first element is used to determine the length of the remaining elements. >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] >>> letters, numbers = unzip(iterable) >>> list(letters) ['a', 'b', 'c', 'd'] >>> list(numbers) [1, 2, 3, 4] This is similar to using ``zip(*iterable)``, but it avoids reading *iterable* into memory. Note, however, that this function uses :func:`itertools.tee` and thus may require significant storage. """ head, iterable = spy(iter(iterable)) if not head: # empty iterable, e.g. zip([], [], []) return () # spy returns a one-length iterable as head head = head[0] iterables = tee(iterable, len(head)) def itemgetter(i): def getter(obj): try: return obj[i] except IndexError: # basically if we have an iterable like # iter([(1, 2, 3), (4, 5), (6,)]) # the second unzipped iterable would fail at the third tuple # since it would try to access tup[1] # same with the third unzipped iterable and the second tuple # to support these "improperly zipped" iterables, # we create a custom itemgetter # which just stops the unzipped iterables # at first length mismatch raise StopIteration return getter return tuple(map(itemgetter(i), it) for i, it in enumerate(iterables)) def divide(n, iterable): """Divide the elements from *iterable* into *n* parts, maintaining order. >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6]) >>> list(group_1) [1, 2, 3] >>> list(group_2) [4, 5, 6] If the length of *iterable* is not evenly divisible by *n*, then the length of the returned iterables will not be identical: >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7]) >>> [list(c) for c in children] [[1, 2, 3], [4, 5], [6, 7]] If the length of the iterable is smaller than n, then the last returned iterables will be empty: >>> children = divide(5, [1, 2, 3]) >>> [list(c) for c in children] [[1], [2], [3], [], []] This function will exhaust the iterable before returning and may require significant storage. If order is not important, see :func:`distribute`, which does not first pull the iterable into memory. """ if n < 1: raise ValueError('n must be at least 1') try: iterable[:0] except TypeError: seq = tuple(iterable) else: seq = iterable q, r = divmod(len(seq), n) ret = [] stop = 0 for i in range(1, n + 1): start = stop stop += q + 1 if i <= r else q ret.append(iter(seq[start:stop])) return ret def always_iterable(obj, base_type=(str, bytes)): """If *obj* is iterable, return an iterator over its items:: >>> obj = (1, 2, 3) >>> list(always_iterable(obj)) [1, 2, 3] If *obj* is not iterable, return a one-item iterable containing *obj*:: >>> obj = 1 >>> list(always_iterable(obj)) [1] If *obj* is ``None``, return an empty iterable: >>> obj = None >>> list(always_iterable(None)) [] By default, binary and text strings are not considered iterable:: >>> obj = 'foo' >>> list(always_iterable(obj)) ['foo'] If *base_type* is set, objects for which ``isinstance(obj, base_type)`` returns ``True`` won't be considered iterable. >>> obj = {'a': 1} >>> list(always_iterable(obj)) # Iterate over the dict's keys ['a'] >>> list(always_iterable(obj, base_type=dict)) # Treat dicts as a unit [{'a': 1}] Set *base_type* to ``None`` to avoid any special handling and treat objects Python considers iterable as iterable: >>> obj = 'foo' >>> list(always_iterable(obj, base_type=None)) ['f', 'o', 'o'] """ if obj is None: return iter(()) if (base_type is not None) and isinstance(obj, base_type): return iter((obj,)) try: return iter(obj) except TypeError: return iter((obj,)) def adjacent(predicate, iterable, distance=1): """Return an iterable over `(bool, item)` tuples where the `item` is drawn from *iterable* and the `bool` indicates whether that item satisfies the *predicate* or is adjacent to an item that does. For example, to find whether items are adjacent to a ``3``:: >>> list(adjacent(lambda x: x == 3, range(6))) [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)] Set *distance* to change what counts as adjacent. For example, to find whether items are two places away from a ``3``: >>> list(adjacent(lambda x: x == 3, range(6), distance=2)) [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)] This is useful for contextualizing the results of a search function. For example, a code comparison tool might want to identify lines that have changed, but also surrounding lines to give the viewer of the diff context. The predicate function will only be called once for each item in the iterable. See also :func:`groupby_transform`, which can be used with this function to group ranges of items with the same `bool` value. """ # Allow distance=0 mainly for testing that it reproduces results with map() if distance < 0: raise ValueError('distance must be at least 0') i1, i2 = tee(iterable) padding = [False] * distance selected = chain(padding, map(predicate, i1), padding) adjacent_to_selected = map(any, windowed(selected, 2 * distance + 1)) return zip(adjacent_to_selected, i2) def groupby_transform(iterable, keyfunc=None, valuefunc=None, reducefunc=None): """An extension of :func:`itertools.groupby` that can apply transformations to the grouped data. * *keyfunc* is a function computing a key value for each item in *iterable* * *valuefunc* is a function that transforms the individual items from *iterable* after grouping * *reducefunc* is a function that transforms each group of items >>> iterable = 'aAAbBBcCC' >>> keyfunc = lambda k: k.upper() >>> valuefunc = lambda v: v.lower() >>> reducefunc = lambda g: ''.join(g) >>> list(groupby_transform(iterable, keyfunc, valuefunc, reducefunc)) [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')] Each optional argument defaults to an identity function if not specified. :func:`groupby_transform` is useful when grouping elements of an iterable using a separate iterable as the key. To do this, :func:`zip` the iterables and pass a *keyfunc* that extracts the first element and a *valuefunc* that extracts the second element:: >>> from operator import itemgetter >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3] >>> values = 'abcdefghi' >>> iterable = zip(keys, values) >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1)) >>> [(k, ''.join(g)) for k, g in grouper] [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')] Note that the order of items in the iterable is significant. Only adjacent items are grouped together, so if you don't want any duplicate groups, you should sort the iterable by the key function. """ ret = groupby(iterable, keyfunc) if valuefunc: ret = ((k, map(valuefunc, g)) for k, g in ret) if reducefunc: ret = ((k, reducefunc(g)) for k, g in ret) return ret class numeric_range(abc.Sequence, abc.Hashable): """An extension of the built-in ``range()`` function whose arguments can be any orderable numeric type. With only *stop* specified, *start* defaults to ``0`` and *step* defaults to ``1``. The output items will match the type of *stop*: >>> list(numeric_range(3.5)) [0.0, 1.0, 2.0, 3.0] With only *start* and *stop* specified, *step* defaults to ``1``. The output items will match the type of *start*: >>> from decimal import Decimal >>> start = Decimal('2.1') >>> stop = Decimal('5.1') >>> list(numeric_range(start, stop)) [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')] With *start*, *stop*, and *step* specified the output items will match the type of ``start + step``: >>> from fractions import Fraction >>> start = Fraction(1, 2) # Start at 1/2 >>> stop = Fraction(5, 2) # End at 5/2 >>> step = Fraction(1, 2) # Count by 1/2 >>> list(numeric_range(start, stop, step)) [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)] If *step* is zero, ``ValueError`` is raised. Negative steps are supported: >>> list(numeric_range(3, -1, -1.0)) [3.0, 2.0, 1.0, 0.0] Be aware of the limitations of floating point numbers; the representation of the yielded numbers may be surprising. ``datetime.datetime`` objects can be used for *start* and *stop*, if *step* is a ``datetime.timedelta`` object: >>> import datetime >>> start = datetime.datetime(2019, 1, 1) >>> stop = datetime.datetime(2019, 1, 3) >>> step = datetime.timedelta(days=1) >>> items = iter(numeric_range(start, stop, step)) >>> next(items) datetime.datetime(2019, 1, 1, 0, 0) >>> next(items) datetime.datetime(2019, 1, 2, 0, 0) """ _EMPTY_HASH = hash(range(0, 0)) def __init__(self, *args): argc = len(args) if argc == 1: (self._stop,) = args self._start = type(self._stop)(0) self._step = type(self._stop - self._start)(1) elif argc == 2: self._start, self._stop = args self._step = type(self._stop - self._start)(1) elif argc == 3: self._start, self._stop, self._step = args elif argc == 0: raise TypeError( 'numeric_range expected at least ' '1 argument, got {}'.format(argc) ) else: raise TypeError( 'numeric_range expected at most ' '3 arguments, got {}'.format(argc) ) self._zero = type(self._step)(0) if self._step == self._zero: raise ValueError('numeric_range() arg 3 must not be zero') self._growing = self._step > self._zero self._init_len() def __bool__(self): if self._growing: return self._start < self._stop else: return self._start > self._stop def __contains__(self, elem): if self._growing: if self._start <= elem < self._stop: return (elem - self._start) % self._step == self._zero else: if self._start >= elem > self._stop: return (self._start - elem) % (-self._step) == self._zero return False def __eq__(self, other): if isinstance(other, numeric_range): empty_self = not bool(self) empty_other = not bool(other) if empty_self or empty_other: return empty_self and empty_other # True if both empty else: return ( self._start == other._start and self._step == other._step and self._get_by_index(-1) == other._get_by_index(-1) ) else: return False def __getitem__(self, key): if isinstance(key, int): return self._get_by_index(key) elif isinstance(key, slice): step = self._step if key.step is None else key.step * self._step if key.start is None or key.start <= -self._len: start = self._start elif key.start >= self._len: start = self._stop else: # -self._len < key.start < self._len start = self._get_by_index(key.start) if key.stop is None or key.stop >= self._len: stop = self._stop elif key.stop <= -self._len: stop = self._start else: # -self._len < key.stop < self._len stop = self._get_by_index(key.stop) return numeric_range(start, stop, step) else: raise TypeError( 'numeric range indices must be ' 'integers or slices, not {}'.format(type(key).__name__) ) def __hash__(self): if self: return hash((self._start, self._get_by_index(-1), self._step)) else: return self._EMPTY_HASH def __iter__(self): values = (self._start + (n * self._step) for n in count()) if self._growing: return takewhile(partial(gt, self._stop), values) else: return takewhile(partial(lt, self._stop), values) def __len__(self): return self._len def _init_len(self): if self._growing: start = self._start stop = self._stop step = self._step else: start = self._stop stop = self._start step = -self._step distance = stop - start if distance <= self._zero: self._len = 0 else: # distance > 0 and step > 0: regular euclidean division q, r = divmod(distance, step) self._len = int(q) + int(r != self._zero) def __reduce__(self): return numeric_range, (self._start, self._stop, self._step) def __repr__(self): if self._step == 1: return "numeric_range({}, {})".format( repr(self._start), repr(self._stop) ) else: return "numeric_range({}, {}, {})".format( repr(self._start), repr(self._stop), repr(self._step) ) def __reversed__(self): return iter( numeric_range( self._get_by_index(-1), self._start - self._step, -self._step ) ) def count(self, value): return int(value in self) def index(self, value): if self._growing: if self._start <= value < self._stop: q, r = divmod(value - self._start, self._step) if r == self._zero: return int(q) else: if self._start >= value > self._stop: q, r = divmod(self._start - value, -self._step) if r == self._zero: return int(q) raise ValueError("{} is not in numeric range".format(value)) def _get_by_index(self, i): if i < 0: i += self._len if i < 0 or i >= self._len: raise IndexError("numeric range object index out of range") return self._start + i * self._step def count_cycle(iterable, n=None): """Cycle through the items from *iterable* up to *n* times, yielding the number of completed cycles along with each item. If *n* is omitted the process repeats indefinitely. >>> list(count_cycle('AB', 3)) [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')] """ iterable = tuple(iterable) if not iterable: return iter(()) counter = count() if n is None else range(n) return ((i, item) for i in counter for item in iterable) def mark_ends(iterable): """Yield 3-tuples of the form ``(is_first, is_last, item)``. >>> list(mark_ends('ABC')) [(True, False, 'A'), (False, False, 'B'), (False, True, 'C')] Use this when looping over an iterable to take special action on its first and/or last items: >>> iterable = ['Header', 100, 200, 'Footer'] >>> total = 0 >>> for is_first, is_last, item in mark_ends(iterable): ... if is_first: ... continue # Skip the header ... if is_last: ... continue # Skip the footer ... total += item >>> print(total) 300 """ it = iter(iterable) try: b = next(it) except StopIteration: return try: for i in count(): a = b b = next(it) yield i == 0, False, a except StopIteration: yield i == 0, True, a def locate(iterable, pred=bool, window_size=None): """Yield the index of each item in *iterable* for which *pred* returns ``True``. *pred* defaults to :func:`bool`, which will select truthy items: >>> list(locate([0, 1, 1, 0, 1, 0, 0])) [1, 2, 4] Set *pred* to a custom function to, e.g., find the indexes for a particular item. >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b')) [1, 3] If *window_size* is given, then the *pred* function will be called with that many items. This enables searching for sub-sequences: >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3] >>> pred = lambda *args: args == (1, 2, 3) >>> list(locate(iterable, pred=pred, window_size=3)) [1, 5, 9] Use with :func:`seekable` to find indexes and then retrieve the associated items: >>> from itertools import count >>> from more_itertools import seekable >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count()) >>> it = seekable(source) >>> pred = lambda x: x > 100 >>> indexes = locate(it, pred=pred) >>> i = next(indexes) >>> it.seek(i) >>> next(it) 106 """ if window_size is None: return compress(count(), map(pred, iterable)) if window_size < 1: raise ValueError('window size must be at least 1') it = windowed(iterable, window_size, fillvalue=_marker) return compress(count(), starmap(pred, it)) def longest_common_prefix(iterables): """Yield elements of the longest common prefix amongst given *iterables*. >>> ''.join(longest_common_prefix(['abcd', 'abc', 'abf'])) 'ab' """ return (c[0] for c in takewhile(all_equal, zip(*iterables))) def lstrip(iterable, pred): """Yield the items from *iterable*, but strip any from the beginning for which *pred* returns ``True``. For example, to remove a set of items from the start of an iterable: >>> iterable = (None, False, None, 1, 2, None, 3, False, None) >>> pred = lambda x: x in {None, False, ''} >>> list(lstrip(iterable, pred)) [1, 2, None, 3, False, None] This function is analogous to to :func:`str.lstrip`, and is essentially an wrapper for :func:`itertools.dropwhile`. """ return dropwhile(pred, iterable) def rstrip(iterable, pred): """Yield the items from *iterable*, but strip any from the end for which *pred* returns ``True``. For example, to remove a set of items from the end of an iterable: >>> iterable = (None, False, None, 1, 2, None, 3, False, None) >>> pred = lambda x: x in {None, False, ''} >>> list(rstrip(iterable, pred)) [None, False, None, 1, 2, None, 3] This function is analogous to :func:`str.rstrip`. """ cache = [] cache_append = cache.append cache_clear = cache.clear for x in iterable: if pred(x): cache_append(x) else: yield from cache cache_clear() yield x def strip(iterable, pred): """Yield the items from *iterable*, but strip any from the beginning and end for which *pred* returns ``True``. For example, to remove a set of items from both ends of an iterable: >>> iterable = (None, False, None, 1, 2, None, 3, False, None) >>> pred = lambda x: x in {None, False, ''} >>> list(strip(iterable, pred)) [1, 2, None, 3] This function is analogous to :func:`str.strip`. """ return rstrip(lstrip(iterable, pred), pred) class islice_extended: """An extension of :func:`itertools.islice` that supports negative values for *stop*, *start*, and *step*. >>> iterable = iter('abcdefgh') >>> list(islice_extended(iterable, -4, -1)) ['e', 'f', 'g'] Slices with negative values require some caching of *iterable*, but this function takes care to minimize the amount of memory required. For example, you can use a negative step with an infinite iterator: >>> from itertools import count >>> list(islice_extended(count(), 110, 99, -2)) [110, 108, 106, 104, 102, 100] You can also use slice notation directly: >>> iterable = map(str, count()) >>> it = islice_extended(iterable)[10:20:2] >>> list(it) ['10', '12', '14', '16', '18'] """ def __init__(self, iterable, *args): it = iter(iterable) if args: self._iterable = _islice_helper(it, slice(*args)) else: self._iterable = it def __iter__(self): return self def __next__(self): return next(self._iterable) def __getitem__(self, key): if isinstance(key, slice): return islice_extended(_islice_helper(self._iterable, key)) raise TypeError('islice_extended.__getitem__ argument must be a slice') def _islice_helper(it, s): start = s.start stop = s.stop if s.step == 0: raise ValueError('step argument must be a non-zero integer or None.') step = s.step or 1 if step > 0: start = 0 if (start is None) else start if start < 0: # Consume all but the last -start items cache = deque(enumerate(it, 1), maxlen=-start) len_iter = cache[-1][0] if cache else 0 # Adjust start to be positive i = max(len_iter + start, 0) # Adjust stop to be positive if stop is None: j = len_iter elif stop >= 0: j = min(stop, len_iter) else: j = max(len_iter + stop, 0) # Slice the cache n = j - i if n <= 0: return for index, item in islice(cache, 0, n, step): yield item elif (stop is not None) and (stop < 0): # Advance to the start position next(islice(it, start, start), None) # When stop is negative, we have to carry -stop items while # iterating cache = deque(islice(it, -stop), maxlen=-stop) for index, item in enumerate(it): cached_item = cache.popleft() if index % step == 0: yield cached_item cache.append(item) else: # When both start and stop are positive we have the normal case yield from islice(it, start, stop, step) else: start = -1 if (start is None) else start if (stop is not None) and (stop < 0): # Consume all but the last items n = -stop - 1 cache = deque(enumerate(it, 1), maxlen=n) len_iter = cache[-1][0] if cache else 0 # If start and stop are both negative they are comparable and # we can just slice. Otherwise we can adjust start to be negative # and then slice. if start < 0: i, j = start, stop else: i, j = min(start - len_iter, -1), None for index, item in list(cache)[i:j:step]: yield item else: # Advance to the stop position if stop is not None: m = stop + 1 next(islice(it, m, m), None) # stop is positive, so if start is negative they are not comparable # and we need the rest of the items. if start < 0: i = start n = None # stop is None and start is positive, so we just need items up to # the start index. elif stop is None: i = None n = start + 1 # Both stop and start are positive, so they are comparable. else: i = None n = start - stop if n <= 0: return cache = list(islice(it, n)) yield from cache[i::step] def always_reversible(iterable): """An extension of :func:`reversed` that supports all iterables, not just those which implement the ``Reversible`` or ``Sequence`` protocols. >>> print(*always_reversible(x for x in range(3))) 2 1 0 If the iterable is already reversible, this function returns the result of :func:`reversed()`. If the iterable is not reversible, this function will cache the remaining items in the iterable and yield them in reverse order, which may require significant storage. """ try: return reversed(iterable) except TypeError: return reversed(list(iterable)) def consecutive_groups(iterable, ordering=lambda x: x): """Yield groups of consecutive items using :func:`itertools.groupby`. The *ordering* function determines whether two items are adjacent by returning their position. By default, the ordering function is the identity function. This is suitable for finding runs of numbers: >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40] >>> for group in consecutive_groups(iterable): ... print(list(group)) [1] [10, 11, 12] [20] [30, 31, 32, 33] [40] For finding runs of adjacent letters, try using the :meth:`index` method of a string of letters: >>> from string import ascii_lowercase >>> iterable = 'abcdfgilmnop' >>> ordering = ascii_lowercase.index >>> for group in consecutive_groups(iterable, ordering): ... print(list(group)) ['a', 'b', 'c', 'd'] ['f', 'g'] ['i'] ['l', 'm', 'n', 'o', 'p'] Each group of consecutive items is an iterator that shares it source with *iterable*. When an an output group is advanced, the previous group is no longer available unless its elements are copied (e.g., into a ``list``). >>> iterable = [1, 2, 11, 12, 21, 22] >>> saved_groups = [] >>> for group in consecutive_groups(iterable): ... saved_groups.append(list(group)) # Copy group elements >>> saved_groups [[1, 2], [11, 12], [21, 22]] """ for k, g in groupby( enumerate(iterable), key=lambda x: x[0] - ordering(x[1]) ): yield map(itemgetter(1), g) def difference(iterable, func=sub, *, initial=None): """This function is the inverse of :func:`itertools.accumulate`. By default it will compute the first difference of *iterable* using :func:`operator.sub`: >>> from itertools import accumulate >>> iterable = accumulate([0, 1, 2, 3, 4]) # produces 0, 1, 3, 6, 10 >>> list(difference(iterable)) [0, 1, 2, 3, 4] *func* defaults to :func:`operator.sub`, but other functions can be specified. They will be applied as follows:: A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ... For example, to do progressive division: >>> iterable = [1, 2, 6, 24, 120] >>> func = lambda x, y: x // y >>> list(difference(iterable, func)) [1, 2, 3, 4, 5] If the *initial* keyword is set, the first element will be skipped when computing successive differences. >>> it = [10, 11, 13, 16] # from accumulate([1, 2, 3], initial=10) >>> list(difference(it, initial=10)) [1, 2, 3] """ a, b = tee(iterable) try: first = [next(b)] except StopIteration: return iter([]) if initial is not None: first = [] return chain(first, map(func, b, a)) class SequenceView(Sequence): """Return a read-only view of the sequence object *target*. :class:`SequenceView` objects are analogous to Python's built-in "dictionary view" types. They provide a dynamic view of a sequence's items, meaning that when the sequence updates, so does the view. >>> seq = ['0', '1', '2'] >>> view = SequenceView(seq) >>> view SequenceView(['0', '1', '2']) >>> seq.append('3') >>> view SequenceView(['0', '1', '2', '3']) Sequence views support indexing, slicing, and length queries. They act like the underlying sequence, except they don't allow assignment: >>> view[1] '1' >>> view[1:-1] ['1', '2'] >>> len(view) 4 Sequence views are useful as an alternative to copying, as they don't require (much) extra storage. """ def __init__(self, target): if not isinstance(target, Sequence): raise TypeError self._target = target def __getitem__(self, index): return self._target[index] def __len__(self): return len(self._target) def __repr__(self): return '{}({})'.format(self.__class__.__name__, repr(self._target)) class seekable: """Wrap an iterator to allow for seeking backward and forward. This progressively caches the items in the source iterable so they can be re-visited. Call :meth:`seek` with an index to seek to that position in the source iterable. To "reset" an iterator, seek to ``0``: >>> from itertools import count >>> it = seekable((str(n) for n in count())) >>> next(it), next(it), next(it) ('0', '1', '2') >>> it.seek(0) >>> next(it), next(it), next(it) ('0', '1', '2') >>> next(it) '3' You can also seek forward: >>> it = seekable((str(n) for n in range(20))) >>> it.seek(10) >>> next(it) '10' >>> it.seek(20) # Seeking past the end of the source isn't a problem >>> list(it) [] >>> it.seek(0) # Resetting works even after hitting the end >>> next(it), next(it), next(it) ('0', '1', '2') Call :meth:`peek` to look ahead one item without advancing the iterator: >>> it = seekable('1234') >>> it.peek() '1' >>> list(it) ['1', '2', '3', '4'] >>> it.peek(default='empty') 'empty' Before the iterator is at its end, calling :func:`bool` on it will return ``True``. After it will return ``False``: >>> it = seekable('5678') >>> bool(it) True >>> list(it) ['5', '6', '7', '8'] >>> bool(it) False You may view the contents of the cache with the :meth:`elements` method. That returns a :class:`SequenceView`, a view that updates automatically: >>> it = seekable((str(n) for n in range(10))) >>> next(it), next(it), next(it) ('0', '1', '2') >>> elements = it.elements() >>> elements SequenceView(['0', '1', '2']) >>> next(it) '3' >>> elements SequenceView(['0', '1', '2', '3']) By default, the cache grows as the source iterable progresses, so beware of wrapping very large or infinite iterables. Supply *maxlen* to limit the size of the cache (this of course limits how far back you can seek). >>> from itertools import count >>> it = seekable((str(n) for n in count()), maxlen=2) >>> next(it), next(it), next(it), next(it) ('0', '1', '2', '3') >>> list(it.elements()) ['2', '3'] >>> it.seek(0) >>> next(it), next(it), next(it), next(it) ('2', '3', '4', '5') >>> next(it) '6' """ def __init__(self, iterable, maxlen=None): self._source = iter(iterable) if maxlen is None: self._cache = [] else: self._cache = deque([], maxlen) self._index = None def __iter__(self): return self def __next__(self): if self._index is not None: try: item = self._cache[self._index] except IndexError: self._index = None else: self._index += 1 return item item = next(self._source) self._cache.append(item) return item def __bool__(self): try: self.peek() except StopIteration: return False return True def peek(self, default=_marker): try: peeked = next(self) except StopIteration: if default is _marker: raise return default if self._index is None: self._index = len(self._cache) self._index -= 1 return peeked def elements(self): return SequenceView(self._cache) def seek(self, index): self._index = index remainder = index - len(self._cache) if remainder > 0: consume(self, remainder) class run_length: """ :func:`run_length.encode` compresses an iterable with run-length encoding. It yields groups of repeated items with the count of how many times they were repeated: >>> uncompressed = 'abbcccdddd' >>> list(run_length.encode(uncompressed)) [('a', 1), ('b', 2), ('c', 3), ('d', 4)] :func:`run_length.decode` decompresses an iterable that was previously compressed with run-length encoding. It yields the items of the decompressed iterable: >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)] >>> list(run_length.decode(compressed)) ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd'] """ @staticmethod def encode(iterable): return ((k, ilen(g)) for k, g in groupby(iterable)) @staticmethod def decode(iterable): return chain.from_iterable(repeat(k, n) for k, n in iterable) def exactly_n(iterable, n, predicate=bool): """Return ``True`` if exactly ``n`` items in the iterable are ``True`` according to the *predicate* function. >>> exactly_n([True, True, False], 2) True >>> exactly_n([True, True, False], 1) False >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3) True The iterable will be advanced until ``n + 1`` truthy items are encountered, so avoid calling it on infinite iterables. """ return len(take(n + 1, filter(predicate, iterable))) == n def circular_shifts(iterable): """Return a list of circular shifts of *iterable*. >>> circular_shifts(range(4)) [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)] """ lst = list(iterable) return take(len(lst), windowed(cycle(lst), len(lst))) def make_decorator(wrapping_func, result_index=0): """Return a decorator version of *wrapping_func*, which is a function that modifies an iterable. *result_index* is the position in that function's signature where the iterable goes. This lets you use itertools on the "production end," i.e. at function definition. This can augment what the function returns without changing the function's code. For example, to produce a decorator version of :func:`chunked`: >>> from more_itertools import chunked >>> chunker = make_decorator(chunked, result_index=0) >>> @chunker(3) ... def iter_range(n): ... return iter(range(n)) ... >>> list(iter_range(9)) [[0, 1, 2], [3, 4, 5], [6, 7, 8]] To only allow truthy items to be returned: >>> truth_serum = make_decorator(filter, result_index=1) >>> @truth_serum(bool) ... def boolean_test(): ... return [0, 1, '', ' ', False, True] ... >>> list(boolean_test()) [1, ' ', True] The :func:`peekable` and :func:`seekable` wrappers make for practical decorators: >>> from more_itertools import peekable >>> peekable_function = make_decorator(peekable) >>> @peekable_function() ... def str_range(*args): ... return (str(x) for x in range(*args)) ... >>> it = str_range(1, 20, 2) >>> next(it), next(it), next(it) ('1', '3', '5') >>> it.peek() '7' >>> next(it) '7' """ # See https://sites.google.com/site/bbayles/index/decorator_factory for # notes on how this works. def decorator(*wrapping_args, **wrapping_kwargs): def outer_wrapper(f): def inner_wrapper(*args, **kwargs): result = f(*args, **kwargs) wrapping_args_ = list(wrapping_args) wrapping_args_.insert(result_index, result) return wrapping_func(*wrapping_args_, **wrapping_kwargs) return inner_wrapper return outer_wrapper return decorator def map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None): """Return a dictionary that maps the items in *iterable* to categories defined by *keyfunc*, transforms them with *valuefunc*, and then summarizes them by category with *reducefunc*. *valuefunc* defaults to the identity function if it is unspecified. If *reducefunc* is unspecified, no summarization takes place: >>> keyfunc = lambda x: x.upper() >>> result = map_reduce('abbccc', keyfunc) >>> sorted(result.items()) [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])] Specifying *valuefunc* transforms the categorized items: >>> keyfunc = lambda x: x.upper() >>> valuefunc = lambda x: 1 >>> result = map_reduce('abbccc', keyfunc, valuefunc) >>> sorted(result.items()) [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])] Specifying *reducefunc* summarizes the categorized items: >>> keyfunc = lambda x: x.upper() >>> valuefunc = lambda x: 1 >>> reducefunc = sum >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc) >>> sorted(result.items()) [('A', 1), ('B', 2), ('C', 3)] You may want to filter the input iterable before applying the map/reduce procedure: >>> all_items = range(30) >>> items = [x for x in all_items if 10 <= x <= 20] # Filter >>> keyfunc = lambda x: x % 2 # Evens map to 0; odds to 1 >>> categories = map_reduce(items, keyfunc=keyfunc) >>> sorted(categories.items()) [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])] >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum) >>> sorted(summaries.items()) [(0, 90), (1, 75)] Note that all items in the iterable are gathered into a list before the summarization step, which may require significant storage. The returned object is a :obj:`collections.defaultdict` with the ``default_factory`` set to ``None``, such that it behaves like a normal dictionary. """ valuefunc = (lambda x: x) if (valuefunc is None) else valuefunc ret = defaultdict(list) for item in iterable: key = keyfunc(item) value = valuefunc(item) ret[key].append(value) if reducefunc is not None: for key, value_list in ret.items(): ret[key] = reducefunc(value_list) ret.default_factory = None return ret def rlocate(iterable, pred=bool, window_size=None): """Yield the index of each item in *iterable* for which *pred* returns ``True``, starting from the right and moving left. *pred* defaults to :func:`bool`, which will select truthy items: >>> list(rlocate([0, 1, 1, 0, 1, 0, 0])) # Truthy at 1, 2, and 4 [4, 2, 1] Set *pred* to a custom function to, e.g., find the indexes for a particular item: >>> iterable = iter('abcb') >>> pred = lambda x: x == 'b' >>> list(rlocate(iterable, pred)) [3, 1] If *window_size* is given, then the *pred* function will be called with that many items. This enables searching for sub-sequences: >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3] >>> pred = lambda *args: args == (1, 2, 3) >>> list(rlocate(iterable, pred=pred, window_size=3)) [9, 5, 1] Beware, this function won't return anything for infinite iterables. If *iterable* is reversible, ``rlocate`` will reverse it and search from the right. Otherwise, it will search from the left and return the results in reverse order. See :func:`locate` to for other example applications. """ if window_size is None: try: len_iter = len(iterable) return (len_iter - i - 1 for i in locate(reversed(iterable), pred)) except TypeError: pass return reversed(list(locate(iterable, pred, window_size))) def replace(iterable, pred, substitutes, count=None, window_size=1): """Yield the items from *iterable*, replacing the items for which *pred* returns ``True`` with the items from the iterable *substitutes*. >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1] >>> pred = lambda x: x == 0 >>> substitutes = (2, 3) >>> list(replace(iterable, pred, substitutes)) [1, 1, 2, 3, 1, 1, 2, 3, 1, 1] If *count* is given, the number of replacements will be limited: >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0] >>> pred = lambda x: x == 0 >>> substitutes = [None] >>> list(replace(iterable, pred, substitutes, count=2)) [1, 1, None, 1, 1, None, 1, 1, 0] Use *window_size* to control the number of items passed as arguments to *pred*. This allows for locating and replacing subsequences. >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5] >>> window_size = 3 >>> pred = lambda *args: args == (0, 1, 2) # 3 items passed to pred >>> substitutes = [3, 4] # Splice in these items >>> list(replace(iterable, pred, substitutes, window_size=window_size)) [3, 4, 5, 3, 4, 5] """ if window_size < 1: raise ValueError('window_size must be at least 1') # Save the substitutes iterable, since it's used more than once substitutes = tuple(substitutes) # Add padding such that the number of windows matches the length of the # iterable it = chain(iterable, [_marker] * (window_size - 1)) windows = windowed(it, window_size) n = 0 for w in windows: # If the current window matches our predicate (and we haven't hit # our maximum number of replacements), splice in the substitutes # and then consume the following windows that overlap with this one. # For example, if the iterable is (0, 1, 2, 3, 4...) # and the window size is 2, we have (0, 1), (1, 2), (2, 3)... # If the predicate matches on (0, 1), we need to zap (0, 1) and (1, 2) if pred(*w): if (count is None) or (n < count): n += 1 yield from substitutes consume(windows, window_size - 1) continue # If there was no match (or we've reached the replacement limit), # yield the first item from the window. if w and (w[0] is not _marker): yield w[0] def partitions(iterable): """Yield all possible order-preserving partitions of *iterable*. >>> iterable = 'abc' >>> for part in partitions(iterable): ... print([''.join(p) for p in part]) ['abc'] ['a', 'bc'] ['ab', 'c'] ['a', 'b', 'c'] This is unrelated to :func:`partition`. """ sequence = list(iterable) n = len(sequence) for i in powerset(range(1, n)): yield [sequence[i:j] for i, j in zip((0,) + i, i + (n,))] def set_partitions(iterable, k=None): """ Yield the set partitions of *iterable* into *k* parts. Set partitions are not order-preserving. >>> iterable = 'abc' >>> for part in set_partitions(iterable, 2): ... print([''.join(p) for p in part]) ['a', 'bc'] ['ab', 'c'] ['b', 'ac'] If *k* is not given, every set partition is generated. >>> iterable = 'abc' >>> for part in set_partitions(iterable): ... print([''.join(p) for p in part]) ['abc'] ['a', 'bc'] ['ab', 'c'] ['b', 'ac'] ['a', 'b', 'c'] """ L = list(iterable) n = len(L) if k is not None: if k < 1: raise ValueError( "Can't partition in a negative or zero number of groups" ) elif k > n: return def set_partitions_helper(L, k): n = len(L) if k == 1: yield [L] elif n == k: yield [[s] for s in L] else: e, *M = L for p in set_partitions_helper(M, k - 1): yield [[e], *p] for p in set_partitions_helper(M, k): for i in range(len(p)): yield p[:i] + [[e] + p[i]] + p[i + 1 :] if k is None: for k in range(1, n + 1): yield from set_partitions_helper(L, k) else: yield from set_partitions_helper(L, k) class time_limited: """ Yield items from *iterable* until *limit_seconds* have passed. If the time limit expires before all items have been yielded, the ``timed_out`` parameter will be set to ``True``. >>> from time import sleep >>> def generator(): ... yield 1 ... yield 2 ... sleep(0.2) ... yield 3 >>> iterable = time_limited(0.1, generator()) >>> list(iterable) [1, 2] >>> iterable.timed_out True Note that the time is checked before each item is yielded, and iteration stops if the time elapsed is greater than *limit_seconds*. If your time limit is 1 second, but it takes 2 seconds to generate the first item from the iterable, the function will run for 2 seconds and not yield anything. """ def __init__(self, limit_seconds, iterable): if limit_seconds < 0: raise ValueError('limit_seconds must be positive') self.limit_seconds = limit_seconds self._iterable = iter(iterable) self._start_time = monotonic() self.timed_out = False def __iter__(self): return self def __next__(self): item = next(self._iterable) if monotonic() - self._start_time > self.limit_seconds: self.timed_out = True raise StopIteration return item def only(iterable, default=None, too_long=None): """If *iterable* has only one item, return it. If it has zero items, return *default*. If it has more than one item, raise the exception given by *too_long*, which is ``ValueError`` by default. >>> only([], default='missing') 'missing' >>> only([1]) 1 >>> only([1, 2]) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: Expected exactly one item in iterable, but got 1, 2, and perhaps more.' >>> only([1, 2], too_long=TypeError) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... TypeError Note that :func:`only` attempts to advance *iterable* twice to ensure there is only one item. See :func:`spy` or :func:`peekable` to check iterable contents less destructively. """ it = iter(iterable) first_value = next(it, default) try: second_value = next(it) except StopIteration: pass else: msg = ( 'Expected exactly one item in iterable, but got {!r}, {!r}, ' 'and perhaps more.'.format(first_value, second_value) ) raise too_long or ValueError(msg) return first_value class _IChunk: def __init__(self, iterable, n): self._it = islice(iterable, n) self._cache = deque() def fill_cache(self): self._cache.extend(self._it) def __iter__(self): return self def __next__(self): try: return next(self._it) except StopIteration: if self._cache: return self._cache.popleft() else: raise def ichunked(iterable, n): """Break *iterable* into sub-iterables with *n* elements each. :func:`ichunked` is like :func:`chunked`, but it yields iterables instead of lists. If the sub-iterables are read in order, the elements of *iterable* won't be stored in memory. If they are read out of order, :func:`itertools.tee` is used to cache elements as necessary. >>> from itertools import count >>> all_chunks = ichunked(count(), 4) >>> c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks) >>> list(c_2) # c_1's elements have been cached; c_3's haven't been [4, 5, 6, 7] >>> list(c_1) [0, 1, 2, 3] >>> list(c_3) [8, 9, 10, 11] """ source = peekable(iter(iterable)) ichunk_marker = object() while True: # Check to see whether we're at the end of the source iterable item = source.peek(ichunk_marker) if item is ichunk_marker: return chunk = _IChunk(source, n) yield chunk # Advance the source iterable and fill previous chunk's cache chunk.fill_cache() def iequals(*iterables): """Return ``True`` if all given *iterables* are equal to each other, which means that they contain the same elements in the same order. The function is useful for comparing iterables of different data types or iterables that do not support equality checks. >>> iequals("abc", ['a', 'b', 'c'], ('a', 'b', 'c'), iter("abc")) True >>> iequals("abc", "acb") False Not to be confused with :func:`all_equals`, which checks whether all elements of iterable are equal to each other. """ return all(map(all_equal, zip_longest(*iterables, fillvalue=object()))) def distinct_combinations(iterable, r): """Yield the distinct combinations of *r* items taken from *iterable*. >>> list(distinct_combinations([0, 0, 1], 2)) [(0, 0), (0, 1)] Equivalent to ``set(combinations(iterable))``, except duplicates are not generated and thrown away. For larger input sequences this is much more efficient. """ if r < 0: raise ValueError('r must be non-negative') elif r == 0: yield () return pool = tuple(iterable) generators = [unique_everseen(enumerate(pool), key=itemgetter(1))] current_combo = [None] * r level = 0 while generators: try: cur_idx, p = next(generators[-1]) except StopIteration: generators.pop() level -= 1 continue current_combo[level] = p if level + 1 == r: yield tuple(current_combo) else: generators.append( unique_everseen( enumerate(pool[cur_idx + 1 :], cur_idx + 1), key=itemgetter(1), ) ) level += 1 def filter_except(validator, iterable, *exceptions): """Yield the items from *iterable* for which the *validator* function does not raise one of the specified *exceptions*. *validator* is called for each item in *iterable*. It should be a function that accepts one argument and raises an exception if that item is not valid. >>> iterable = ['1', '2', 'three', '4', None] >>> list(filter_except(int, iterable, ValueError, TypeError)) ['1', '2', '4'] If an exception other than one given by *exceptions* is raised by *validator*, it is raised like normal. """ for item in iterable: try: validator(item) except exceptions: pass else: yield item def map_except(function, iterable, *exceptions): """Transform each item from *iterable* with *function* and yield the result, unless *function* raises one of the specified *exceptions*. *function* is called to transform each item in *iterable*. It should accept one argument. >>> iterable = ['1', '2', 'three', '4', None] >>> list(map_except(int, iterable, ValueError, TypeError)) [1, 2, 4] If an exception other than one given by *exceptions* is raised by *function*, it is raised like normal. """ for item in iterable: try: yield function(item) except exceptions: pass def map_if(iterable, pred, func, func_else=lambda x: x): """Evaluate each item from *iterable* using *pred*. If the result is equivalent to ``True``, transform the item with *func* and yield it. Otherwise, transform the item with *func_else* and yield it. *pred*, *func*, and *func_else* should each be functions that accept one argument. By default, *func_else* is the identity function. >>> from math import sqrt >>> iterable = list(range(-5, 5)) >>> iterable [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4] >>> list(map_if(iterable, lambda x: x > 3, lambda x: 'toobig')) [-5, -4, -3, -2, -1, 0, 1, 2, 3, 'toobig'] >>> list(map_if(iterable, lambda x: x >= 0, ... lambda x: f'{sqrt(x):.2f}', lambda x: None)) [None, None, None, None, None, '0.00', '1.00', '1.41', '1.73', '2.00'] """ for item in iterable: yield func(item) if pred(item) else func_else(item) def _sample_unweighted(iterable, k): # Implementation of "Algorithm L" from the 1994 paper by Kim-Hung Li: # "Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))". # Fill up the reservoir (collection of samples) with the first `k` samples reservoir = take(k, iterable) # Generate random number that's the largest in a sample of k U(0,1) numbers # Largest order statistic: https://en.wikipedia.org/wiki/Order_statistic W = exp(log(random()) / k) # The number of elements to skip before changing the reservoir is a random # number with a geometric distribution. Sample it using random() and logs. next_index = k + floor(log(random()) / log(1 - W)) for index, element in enumerate(iterable, k): if index == next_index: reservoir[randrange(k)] = element # The new W is the largest in a sample of k U(0, `old_W`) numbers W *= exp(log(random()) / k) next_index += floor(log(random()) / log(1 - W)) + 1 return reservoir def _sample_weighted(iterable, k, weights): # Implementation of "A-ExpJ" from the 2006 paper by Efraimidis et al. : # "Weighted random sampling with a reservoir". # Log-transform for numerical stability for weights that are small/large weight_keys = (log(random()) / weight for weight in weights) # Fill up the reservoir (collection of samples) with the first `k` # weight-keys and elements, then heapify the list. reservoir = take(k, zip(weight_keys, iterable)) heapify(reservoir) # The number of jumps before changing the reservoir is a random variable # with an exponential distribution. Sample it using random() and logs. smallest_weight_key, _ = reservoir[0] weights_to_skip = log(random()) / smallest_weight_key for weight, element in zip(weights, iterable): if weight >= weights_to_skip: # The notation here is consistent with the paper, but we store # the weight-keys in log-space for better numerical stability. smallest_weight_key, _ = reservoir[0] t_w = exp(weight * smallest_weight_key) r_2 = uniform(t_w, 1) # generate U(t_w, 1) weight_key = log(r_2) / weight heapreplace(reservoir, (weight_key, element)) smallest_weight_key, _ = reservoir[0] weights_to_skip = log(random()) / smallest_weight_key else: weights_to_skip -= weight # Equivalent to [element for weight_key, element in sorted(reservoir)] return [heappop(reservoir)[1] for _ in range(k)] def sample(iterable, k, weights=None): """Return a *k*-length list of elements chosen (without replacement) from the *iterable*. Like :func:`random.sample`, but works on iterables of unknown length. >>> iterable = range(100) >>> sample(iterable, 5) # doctest: +SKIP [81, 60, 96, 16, 4] An iterable with *weights* may also be given: >>> iterable = range(100) >>> weights = (i * i + 1 for i in range(100)) >>> sampled = sample(iterable, 5, weights=weights) # doctest: +SKIP [79, 67, 74, 66, 78] The algorithm can also be used to generate weighted random permutations. The relative weight of each item determines the probability that it appears late in the permutation. >>> data = "abcdefgh" >>> weights = range(1, len(data) + 1) >>> sample(data, k=len(data), weights=weights) # doctest: +SKIP ['c', 'a', 'b', 'e', 'g', 'd', 'h', 'f'] """ if k == 0: return [] iterable = iter(iterable) if weights is None: return _sample_unweighted(iterable, k) else: weights = iter(weights) return _sample_weighted(iterable, k, weights) def is_sorted(iterable, key=None, reverse=False, strict=False): """Returns ``True`` if the items of iterable are in sorted order, and ``False`` otherwise. *key* and *reverse* have the same meaning that they do in the built-in :func:`sorted` function. >>> is_sorted(['1', '2', '3', '4', '5'], key=int) True >>> is_sorted([5, 4, 3, 1, 2], reverse=True) False If *strict*, tests for strict sorting, that is, returns ``False`` if equal elements are found: >>> is_sorted([1, 2, 2]) True >>> is_sorted([1, 2, 2], strict=True) False The function returns ``False`` after encountering the first out-of-order item. If there are no out-of-order items, the iterable is exhausted. """ compare = (le if reverse else ge) if strict else (lt if reverse else gt) it = iterable if key is None else map(key, iterable) return not any(starmap(compare, pairwise(it))) class AbortThread(BaseException): pass class callback_iter: """Convert a function that uses callbacks to an iterator. Let *func* be a function that takes a `callback` keyword argument. For example: >>> def func(callback=None): ... for i, c in [(1, 'a'), (2, 'b'), (3, 'c')]: ... if callback: ... callback(i, c) ... return 4 Use ``with callback_iter(func)`` to get an iterator over the parameters that are delivered to the callback. >>> with callback_iter(func) as it: ... for args, kwargs in it: ... print(args) (1, 'a') (2, 'b') (3, 'c') The function will be called in a background thread. The ``done`` property indicates whether it has completed execution. >>> it.done True If it completes successfully, its return value will be available in the ``result`` property. >>> it.result 4 Notes: * If the function uses some keyword argument besides ``callback``, supply *callback_kwd*. * If it finished executing, but raised an exception, accessing the ``result`` property will raise the same exception. * If it hasn't finished executing, accessing the ``result`` property from within the ``with`` block will raise ``RuntimeError``. * If it hasn't finished executing, accessing the ``result`` property from outside the ``with`` block will raise a ``more_itertools.AbortThread`` exception. * Provide *wait_seconds* to adjust how frequently the it is polled for output. """ def __init__(self, func, callback_kwd='callback', wait_seconds=0.1): self._func = func self._callback_kwd = callback_kwd self._aborted = False self._future = None self._wait_seconds = wait_seconds # Lazily import concurrent.future self._executor = __import__( ).futures.__import__("concurrent.futures").futures.ThreadPoolExecutor(max_workers=1) self._iterator = self._reader() def __enter__(self): return self def __exit__(self, exc_type, exc_value, traceback): self._aborted = True self._executor.shutdown() def __iter__(self): return self def __next__(self): return next(self._iterator) @property def done(self): if self._future is None: return False return self._future.done() @property def result(self): if not self.done: raise RuntimeError('Function has not yet completed') return self._future.result() def _reader(self): q = Queue() def callback(*args, **kwargs): if self._aborted: raise AbortThread('canceled by user') q.put((args, kwargs)) self._future = self._executor.submit( self._func, **{self._callback_kwd: callback} ) while True: try: item = q.get(timeout=self._wait_seconds) except Empty: pass else: q.task_done() yield item if self._future.done(): break remaining = [] while True: try: item = q.get_nowait() except Empty: break else: q.task_done() remaining.append(item) q.join() yield from remaining def windowed_complete(iterable, n): """ Yield ``(beginning, middle, end)`` tuples, where: * Each ``middle`` has *n* items from *iterable* * Each ``beginning`` has the items before the ones in ``middle`` * Each ``end`` has the items after the ones in ``middle`` >>> iterable = range(7) >>> n = 3 >>> for beginning, middle, end in windowed_complete(iterable, n): ... print(beginning, middle, end) () (0, 1, 2) (3, 4, 5, 6) (0,) (1, 2, 3) (4, 5, 6) (0, 1) (2, 3, 4) (5, 6) (0, 1, 2) (3, 4, 5) (6,) (0, 1, 2, 3) (4, 5, 6) () Note that *n* must be at least 0 and most equal to the length of *iterable*. This function will exhaust the iterable and may require significant storage. """ if n < 0: raise ValueError('n must be >= 0') seq = tuple(iterable) size = len(seq) if n > size: raise ValueError('n must be <= len(seq)') for i in range(size - n + 1): beginning = seq[:i] middle = seq[i : i + n] end = seq[i + n :] yield beginning, middle, end def all_unique(iterable, key=None): """ Returns ``True`` if all the elements of *iterable* are unique (no two elements are equal). >>> all_unique('ABCB') False If a *key* function is specified, it will be used to make comparisons. >>> all_unique('ABCb') True >>> all_unique('ABCb', str.lower) False The function returns as soon as the first non-unique element is encountered. Iterables with a mix of hashable and unhashable items can be used, but the function will be slower for unhashable items. """ seenset = set() seenset_add = seenset.add seenlist = [] seenlist_add = seenlist.append for element in map(key, iterable) if key else iterable: try: if element in seenset: return False seenset_add(element) except TypeError: if element in seenlist: return False seenlist_add(element) return True def nth_product(index, *args): """Equivalent to ``list(product(*args))[index]``. The products of *args* can be ordered lexicographically. :func:`nth_product` computes the product at sort position *index* without computing the previous products. >>> nth_product(8, range(2), range(2), range(2), range(2)) (1, 0, 0, 0) ``IndexError`` will be raised if the given *index* is invalid. """ pools = list(map(tuple, reversed(args))) ns = list(map(len, pools)) c = reduce(mul, ns) if index < 0: index += c if not 0 <= index < c: raise IndexError result = [] for pool, n in zip(pools, ns): result.append(pool[index % n]) index //= n return tuple(reversed(result)) def nth_permutation(iterable, r, index): """Equivalent to ``list(permutations(iterable, r))[index]``` The subsequences of *iterable* that are of length *r* where order is important can be ordered lexicographically. :func:`nth_permutation` computes the subsequence at sort position *index* directly, without computing the previous subsequences. >>> nth_permutation('ghijk', 2, 5) ('h', 'i') ``ValueError`` will be raised If *r* is negative or greater than the length of *iterable*. ``IndexError`` will be raised if the given *index* is invalid. """ pool = list(iterable) n = len(pool) if r is None or r == n: r, c = n, factorial(n) elif not 0 <= r < n: raise ValueError else: c = factorial(n) // factorial(n - r) if index < 0: index += c if not 0 <= index < c: raise IndexError if c == 0: return tuple() result = [0] * r q = index * factorial(n) // c if r < n else index for d in range(1, n + 1): q, i = divmod(q, d) if 0 <= n - d < r: result[n - d] = i if q == 0: break return tuple(map(pool.pop, result)) def value_chain(*args): """Yield all arguments passed to the function in the same order in which they were passed. If an argument itself is iterable then iterate over its values. >>> list(value_chain(1, 2, 3, [4, 5, 6])) [1, 2, 3, 4, 5, 6] Binary and text strings are not considered iterable and are emitted as-is: >>> list(value_chain('12', '34', ['56', '78'])) ['12', '34', '56', '78'] Multiple levels of nesting are not flattened. """ for value in args: if isinstance(value, (str, bytes)): yield value continue try: yield from value except TypeError: yield value def product_index(element, *args): """Equivalent to ``list(product(*args)).index(element)`` The products of *args* can be ordered lexicographically. :func:`product_index` computes the first index of *element* without computing the previous products. >>> product_index([8, 2], range(10), range(5)) 42 ``ValueError`` will be raised if the given *element* isn't in the product of *args*. """ index = 0 for x, pool in zip_longest(element, args, fillvalue=_marker): if x is _marker or pool is _marker: raise ValueError('element is not a product of args') pool = tuple(pool) index = index * len(pool) + pool.index(x) return index def combination_index(element, iterable): """Equivalent to ``list(combinations(iterable, r)).index(element)`` The subsequences of *iterable* that are of length *r* can be ordered lexicographically. :func:`combination_index` computes the index of the first *element*, without computing the previous combinations. >>> combination_index('adf', 'abcdefg') 10 ``ValueError`` will be raised if the given *element* isn't one of the combinations of *iterable*. """ element = enumerate(element) k, y = next(element, (None, None)) if k is None: return 0 indexes = [] pool = enumerate(iterable) for n, x in pool: if x == y: indexes.append(n) tmp, y = next(element, (None, None)) if tmp is None: break else: k = tmp else: raise ValueError('element is not a combination of iterable') n, _ = last(pool, default=(n, None)) # Python versions below 3.8 don't have math.comb index = 1 for i, j in enumerate(reversed(indexes), start=1): j = n - j if i <= j: index += factorial(j) // (factorial(i) * factorial(j - i)) return factorial(n + 1) // (factorial(k + 1) * factorial(n - k)) - index def permutation_index(element, iterable): """Equivalent to ``list(permutations(iterable, r)).index(element)``` The subsequences of *iterable* that are of length *r* where order is important can be ordered lexicographically. :func:`permutation_index` computes the index of the first *element* directly, without computing the previous permutations. >>> permutation_index([1, 3, 2], range(5)) 19 ``ValueError`` will be raised if the given *element* isn't one of the permutations of *iterable*. """ index = 0 pool = list(iterable) for i, x in zip(range(len(pool), -1, -1), element): r = pool.index(x) index = index * i + r del pool[r] return index class countable: """Wrap *iterable* and keep a count of how many items have been consumed. The ``items_seen`` attribute starts at ``0`` and increments as the iterable is consumed: >>> iterable = map(str, range(10)) >>> it = countable(iterable) >>> it.items_seen 0 >>> next(it), next(it) ('0', '1') >>> list(it) ['2', '3', '4', '5', '6', '7', '8', '9'] >>> it.items_seen 10 """ def __init__(self, iterable): self._it = iter(iterable) self.items_seen = 0 def __iter__(self): return self def __next__(self): item = next(self._it) self.items_seen += 1 return item def chunked_even(iterable, n): """Break *iterable* into lists of approximately length *n*. Items are distributed such the lengths of the lists differ by at most 1 item. >>> iterable = [1, 2, 3, 4, 5, 6, 7] >>> n = 3 >>> list(chunked_even(iterable, n)) # List lengths: 3, 2, 2 [[1, 2, 3], [4, 5], [6, 7]] >>> list(chunked(iterable, n)) # List lengths: 3, 3, 1 [[1, 2, 3], [4, 5, 6], [7]] """ len_method = getattr(iterable, '__len__', None) if len_method is None: return _chunked_even_online(iterable, n) else: return _chunked_even_finite(iterable, len_method(), n) def _chunked_even_online(iterable, n): buffer = [] maxbuf = n + (n - 2) * (n - 1) for x in iterable: buffer.append(x) if len(buffer) == maxbuf: yield buffer[:n] buffer = buffer[n:] yield from _chunked_even_finite(buffer, len(buffer), n) def _chunked_even_finite(iterable, N, n): if N < 1: return # Lists are either size `full_size <= n` or `partial_size = full_size - 1` q, r = divmod(N, n) num_lists = q + (1 if r > 0 else 0) q, r = divmod(N, num_lists) full_size = q + (1 if r > 0 else 0) partial_size = full_size - 1 num_full = N - partial_size * num_lists num_partial = num_lists - num_full buffer = [] iterator = iter(iterable) # Yield num_full lists of full_size for x in iterator: buffer.append(x) if len(buffer) == full_size: yield buffer buffer = [] num_full -= 1 if num_full <= 0: break # Yield num_partial lists of partial_size for x in iterator: buffer.append(x) if len(buffer) == partial_size: yield buffer buffer = [] num_partial -= 1 def zip_broadcast(*objects, scalar_types=(str, bytes), strict=False): """A version of :func:`zip` that "broadcasts" any scalar (i.e., non-iterable) items into output tuples. >>> iterable_1 = [1, 2, 3] >>> iterable_2 = ['a', 'b', 'c'] >>> scalar = '_' >>> list(zip_broadcast(iterable_1, iterable_2, scalar)) [(1, 'a', '_'), (2, 'b', '_'), (3, 'c', '_')] The *scalar_types* keyword argument determines what types are considered scalar. It is set to ``(str, bytes)`` by default. Set it to ``None`` to treat strings and byte strings as iterable: >>> list(zip_broadcast('abc', 0, 'xyz', scalar_types=None)) [('a', 0, 'x'), ('b', 0, 'y'), ('c', 0, 'z')] If the *strict* keyword argument is ``True``, then ``UnequalIterablesError`` will be raised if any of the iterables have different lengths. """ def is_scalar(obj): if scalar_types and isinstance(obj, scalar_types): return True try: iter(obj) except TypeError: return True else: return False size = len(objects) if not size: return iterables, iterable_positions = [], [] scalars, scalar_positions = [], [] for i, obj in enumerate(objects): if is_scalar(obj): scalars.append(obj) scalar_positions.append(i) else: iterables.append(iter(obj)) iterable_positions.append(i) if len(scalars) == size: yield tuple(objects) return zipper = _zip_equal if strict else zip for item in zipper(*iterables): new_item = [None] * size for i, elem in zip(iterable_positions, item): new_item[i] = elem for i, elem in zip(scalar_positions, scalars): new_item[i] = elem yield tuple(new_item) def unique_in_window(iterable, n, key=None): """Yield the items from *iterable* that haven't been seen recently. *n* is the size of the lookback window. >>> iterable = [0, 1, 0, 2, 3, 0] >>> n = 3 >>> list(unique_in_window(iterable, n)) [0, 1, 2, 3, 0] The *key* function, if provided, will be used to determine uniqueness: >>> list(unique_in_window('abAcda', 3, key=lambda x: x.lower())) ['a', 'b', 'c', 'd', 'a'] The items in *iterable* must be hashable. """ if n <= 0: raise ValueError('n must be greater than 0') window = deque(maxlen=n) uniques = set() use_key = key is not None for item in iterable: k = key(item) if use_key else item if k in uniques: continue if len(uniques) == n: uniques.discard(window[0]) uniques.add(k) window.append(k) yield item def duplicates_everseen(iterable, key=None): """Yield duplicate elements after their first appearance. >>> list(duplicates_everseen('mississippi')) ['s', 'i', 's', 's', 'i', 'p', 'i'] >>> list(duplicates_everseen('AaaBbbCccAaa', str.lower)) ['a', 'a', 'b', 'b', 'c', 'c', 'A', 'a', 'a'] This function is analagous to :func:`unique_everseen` and is subject to the same performance considerations. """ seen_set = set() seen_list = [] use_key = key is not None for element in iterable: k = key(element) if use_key else element try: if k not in seen_set: seen_set.add(k) else: yield element except TypeError: if k not in seen_list: seen_list.append(k) else: yield element def duplicates_justseen(iterable, key=None): """Yields serially-duplicate elements after their first appearance. >>> list(duplicates_justseen('mississippi')) ['s', 's', 'p'] >>> list(duplicates_justseen('AaaBbbCccAaa', str.lower)) ['a', 'a', 'b', 'b', 'c', 'c', 'a', 'a'] This function is analagous to :func:`unique_justseen`. """ return flatten( map( lambda group_tuple: islice_extended(group_tuple[1])[1:], groupby(iterable, key), ) ) def minmax(iterable_or_value, *others, key=None, default=_marker): """Returns both the smallest and largest items in an iterable or the largest of two or more arguments. >>> minmax([3, 1, 5]) (1, 5) >>> minmax(4, 2, 6) (2, 6) If a *key* function is provided, it will be used to transform the input items for comparison. >>> minmax([5, 30], key=str) # '30' sorts before '5' (30, 5) If a *default* value is provided, it will be returned if there are no input items. >>> minmax([], default=(0, 0)) (0, 0) Otherwise ``ValueError`` is raised. This function is based on the `recipe `__ by Raymond Hettinger and takes care to minimize the number of comparisons performed. """ iterable = (iterable_or_value, *others) if others else iterable_or_value it = iter(iterable) try: lo = hi = next(it) except StopIteration as e: if default is _marker: raise ValueError( '`minmax()` argument is an empty iterable. ' 'Provide a `default` value to suppress this error.' ) from e return default # Different branches depending on the presence of key. This saves a lot # of unimportant copies which would slow the "key=None" branch # significantly down. if key is None: for x, y in zip_longest(it, it, fillvalue=lo): if y < x: x, y = y, x if x < lo: lo = x if hi < y: hi = y else: lo_key = hi_key = key(lo) for x, y in zip_longest(it, it, fillvalue=lo): x_key, y_key = key(x), key(y) if y_key < x_key: x, y, x_key, y_key = y, x, y_key, x_key if x_key < lo_key: lo, lo_key = x, x_key if hi_key < y_key: hi, hi_key = y, y_key return lo, hi def constrained_batches( iterable, max_size, max_count=None, get_len=len, strict=True ): """Yield batches of items from *iterable* with a combined size limited by *max_size*. >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1'] >>> list(constrained_batches(iterable, 10)) [(b'12345', b'123'), (b'12345678', b'1', b'1'), (b'12', b'1')] If a *max_count* is supplied, the number of items per batch is also limited: >>> iterable = [b'12345', b'123', b'12345678', b'1', b'1', b'12', b'1'] >>> list(constrained_batches(iterable, 10, max_count = 2)) [(b'12345', b'123'), (b'12345678', b'1'), (b'1', b'12'), (b'1',)] If a *get_len* function is supplied, use that instead of :func:`len` to determine item size. If *strict* is ``True``, raise ``ValueError`` if any single item is bigger than *max_size*. Otherwise, allow single items to exceed *max_size*. """ if max_size <= 0: raise ValueError('maximum size must be greater than zero') batch = [] batch_size = 0 batch_count = 0 for item in iterable: item_len = get_len(item) if strict and item_len > max_size: raise ValueError('item size exceeds maximum size') reached_count = batch_count == max_count reached_size = item_len + batch_size > max_size if batch_count and (reached_size or reached_count): yield tuple(batch) batch.clear() batch_size = 0 batch_count = 0 batch.append(item) batch_size += item_len batch_count += 1 if batch: yield tuple(batch) def gray_product(*iterables): """Like :func:`itertools.product`, but return tuples in an order such that only one element in the generated tuple changes from one iteration to the next. >>> list(gray_product('AB','CD')) [('A', 'C'), ('B', 'C'), ('B', 'D'), ('A', 'D')] This function consumes all of the input iterables before producing output. If any of the input iterables have fewer than two items, ``ValueError`` is raised. For information on the algorithm, see `this section `__ of Donald Knuth's *The Art of Computer Programming*. """ all_iterables = tuple(tuple(x) for x in iterables) iterable_count = len(all_iterables) for iterable in all_iterables: if len(iterable) < 2: raise ValueError("each iterable must have two or more items") # This is based on "Algorithm H" from section 7.2.1.1, page 20. # a holds the indexes of the source iterables for the n-tuple to be yielded # f is the array of "focus pointers" # o is the array of "directions" a = [0] * iterable_count f = list(range(iterable_count + 1)) o = [1] * iterable_count while True: yield tuple(all_iterables[i][a[i]] for i in range(iterable_count)) j = f[0] f[0] = 0 if j == iterable_count: break a[j] = a[j] + o[j] if a[j] == 0 or a[j] == len(all_iterables[j]) - 1: o[j] = -o[j] f[j] = f[j + 1] f[j + 1] = j + 1 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/more_itertools/recipes.py0000644000175100001730000006151014467657412025036 0ustar00runnerdocker"""Imported from the recipes section of the itertools documentation. All functions taken from the recipes section of the itertools library docs [1]_. Some backward-compatible usability improvements have been made. .. [1] http://docs.python.org/library/itertools.html#recipes """ import math import operator import warnings from collections import deque from collections.abc import Sized from functools import reduce from itertools import ( chain, combinations, compress, count, cycle, groupby, islice, product, repeat, starmap, tee, zip_longest, ) from random import randrange, sample, choice from sys import hexversion __all__ = [ 'all_equal', 'batched', 'before_and_after', 'consume', 'convolve', 'dotproduct', 'first_true', 'factor', 'flatten', 'grouper', 'iter_except', 'iter_index', 'matmul', 'ncycles', 'nth', 'nth_combination', 'padnone', 'pad_none', 'pairwise', 'partition', 'polynomial_from_roots', 'powerset', 'prepend', 'quantify', 'random_combination_with_replacement', 'random_combination', 'random_permutation', 'random_product', 'repeatfunc', 'roundrobin', 'sieve', 'sliding_window', 'subslices', 'tabulate', 'tail', 'take', 'transpose', 'triplewise', 'unique_everseen', 'unique_justseen', ] _marker = object() def take(n, iterable): """Return first *n* items of the iterable as a list. >>> take(3, range(10)) [0, 1, 2] If there are fewer than *n* items in the iterable, all of them are returned. >>> take(10, range(3)) [0, 1, 2] """ return list(islice(iterable, n)) def tabulate(function, start=0): """Return an iterator over the results of ``func(start)``, ``func(start + 1)``, ``func(start + 2)``... *func* should be a function that accepts one integer argument. If *start* is not specified it defaults to 0. It will be incremented each time the iterator is advanced. >>> square = lambda x: x ** 2 >>> iterator = tabulate(square, -3) >>> take(4, iterator) [9, 4, 1, 0] """ return map(function, count(start)) def tail(n, iterable): """Return an iterator over the last *n* items of *iterable*. >>> t = tail(3, 'ABCDEFG') >>> list(t) ['E', 'F', 'G'] """ # If the given iterable has a length, then we can use islice to get its # final elements. Note that if the iterable is not actually Iterable, # either islice or deque will throw a TypeError. This is why we don't # check if it is Iterable. if isinstance(iterable, Sized): yield from islice(iterable, max(0, len(iterable) - n), None) else: yield from iter(deque(iterable, maxlen=n)) def consume(iterator, n=None): """Advance *iterable* by *n* steps. If *n* is ``None``, consume it entirely. Efficiently exhausts an iterator without returning values. Defaults to consuming the whole iterator, but an optional second argument may be provided to limit consumption. >>> i = (x for x in range(10)) >>> next(i) 0 >>> consume(i, 3) >>> next(i) 4 >>> consume(i) >>> next(i) Traceback (most recent call last): File "", line 1, in StopIteration If the iterator has fewer items remaining than the provided limit, the whole iterator will be consumed. >>> i = (x for x in range(3)) >>> consume(i, 5) >>> next(i) Traceback (most recent call last): File "", line 1, in StopIteration """ # Use functions that consume iterators at C speed. if n is None: # feed the entire iterator into a zero-length deque deque(iterator, maxlen=0) else: # advance to the empty slice starting at position n next(islice(iterator, n, n), None) def nth(iterable, n, default=None): """Returns the nth item or a default value. >>> l = range(10) >>> nth(l, 3) 3 >>> nth(l, 20, "zebra") 'zebra' """ return next(islice(iterable, n, None), default) def all_equal(iterable): """ Returns ``True`` if all the elements are equal to each other. >>> all_equal('aaaa') True >>> all_equal('aaab') False """ g = groupby(iterable) return next(g, True) and not next(g, False) def quantify(iterable, pred=bool): """Return the how many times the predicate is true. >>> quantify([True, False, True]) 2 """ return sum(map(pred, iterable)) def pad_none(iterable): """Returns the sequence of elements and then returns ``None`` indefinitely. >>> take(5, pad_none(range(3))) [0, 1, 2, None, None] Useful for emulating the behavior of the built-in :func:`map` function. See also :func:`padded`. """ return chain(iterable, repeat(None)) padnone = pad_none def ncycles(iterable, n): """Returns the sequence elements *n* times >>> list(ncycles(["a", "b"], 3)) ['a', 'b', 'a', 'b', 'a', 'b'] """ return chain.from_iterable(repeat(tuple(iterable), n)) def dotproduct(vec1, vec2): """Returns the dot product of the two iterables. >>> dotproduct([10, 10], [20, 20]) 400 """ return sum(map(operator.mul, vec1, vec2)) def flatten(listOfLists): """Return an iterator flattening one level of nesting in a list of lists. >>> list(flatten([[0, 1], [2, 3]])) [0, 1, 2, 3] See also :func:`collapse`, which can flatten multiple levels of nesting. """ return chain.from_iterable(listOfLists) def repeatfunc(func, times=None, *args): """Call *func* with *args* repeatedly, returning an iterable over the results. If *times* is specified, the iterable will terminate after that many repetitions: >>> from operator import add >>> times = 4 >>> args = 3, 5 >>> list(repeatfunc(add, times, *args)) [8, 8, 8, 8] If *times* is ``None`` the iterable will not terminate: >>> from random import randrange >>> times = None >>> args = 1, 11 >>> take(6, repeatfunc(randrange, times, *args)) # doctest:+SKIP [2, 4, 8, 1, 8, 4] """ if times is None: return starmap(func, repeat(args)) return starmap(func, repeat(args, times)) def _pairwise(iterable): """Returns an iterator of paired items, overlapping, from the original >>> take(4, pairwise(count())) [(0, 1), (1, 2), (2, 3), (3, 4)] On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`. """ a, b = tee(iterable) next(b, None) yield from zip(a, b) try: from itertools import pairwise as itertools_pairwise except ImportError: pairwise = _pairwise else: def pairwise(iterable): yield from itertools_pairwise(iterable) pairwise.__doc__ = _pairwise.__doc__ class UnequalIterablesError(ValueError): def __init__(self, details=None): msg = 'Iterables have different lengths' if details is not None: msg += (': index 0 has length {}; index {} has length {}').format( *details ) super().__init__(msg) def _zip_equal_generator(iterables): for combo in zip_longest(*iterables, fillvalue=_marker): for val in combo: if val is _marker: raise UnequalIterablesError() yield combo def _zip_equal(*iterables): # Check whether the iterables are all the same size. try: first_size = len(iterables[0]) for i, it in enumerate(iterables[1:], 1): size = len(it) if size != first_size: break else: # If we didn't break out, we can use the built-in zip. return zip(*iterables) # If we did break out, there was a mismatch. raise UnequalIterablesError(details=(first_size, i, size)) # If any one of the iterables didn't have a length, start reading # them until one runs out. except TypeError: return _zip_equal_generator(iterables) def grouper(iterable, n, incomplete='fill', fillvalue=None): """Group elements from *iterable* into fixed-length groups of length *n*. >>> list(grouper('ABCDEF', 3)) [('A', 'B', 'C'), ('D', 'E', 'F')] The keyword arguments *incomplete* and *fillvalue* control what happens for iterables whose length is not a multiple of *n*. When *incomplete* is `'fill'`, the last group will contain instances of *fillvalue*. >>> list(grouper('ABCDEFG', 3, incomplete='fill', fillvalue='x')) [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')] When *incomplete* is `'ignore'`, the last group will not be emitted. >>> list(grouper('ABCDEFG', 3, incomplete='ignore', fillvalue='x')) [('A', 'B', 'C'), ('D', 'E', 'F')] When *incomplete* is `'strict'`, a subclass of `ValueError` will be raised. >>> it = grouper('ABCDEFG', 3, incomplete='strict') >>> list(it) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... UnequalIterablesError """ args = [iter(iterable)] * n if incomplete == 'fill': return zip_longest(*args, fillvalue=fillvalue) if incomplete == 'strict': return _zip_equal(*args) if incomplete == 'ignore': return zip(*args) else: raise ValueError('Expected fill, strict, or ignore') def roundrobin(*iterables): """Yields an item from each iterable, alternating between them. >>> list(roundrobin('ABC', 'D', 'EF')) ['A', 'D', 'E', 'B', 'F', 'C'] This function produces the same output as :func:`interleave_longest`, but may perform better for some inputs (in particular when the number of iterables is small). """ # Recipe credited to George Sakkis pending = len(iterables) nexts = cycle(iter(it).__next__ for it in iterables) while pending: try: for next in nexts: yield next() except StopIteration: pending -= 1 nexts = cycle(islice(nexts, pending)) def partition(pred, iterable): """ Returns a 2-tuple of iterables derived from the input iterable. The first yields the items that have ``pred(item) == False``. The second yields the items that have ``pred(item) == True``. >>> is_odd = lambda x: x % 2 != 0 >>> iterable = range(10) >>> even_items, odd_items = partition(is_odd, iterable) >>> list(even_items), list(odd_items) ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9]) If *pred* is None, :func:`bool` is used. >>> iterable = [0, 1, False, True, '', ' '] >>> false_items, true_items = partition(None, iterable) >>> list(false_items), list(true_items) ([0, False, ''], [1, True, ' ']) """ if pred is None: pred = bool evaluations = ((pred(x), x) for x in iterable) t1, t2 = tee(evaluations) return ( (x for (cond, x) in t1 if not cond), (x for (cond, x) in t2 if cond), ) def powerset(iterable): """Yields all possible subsets of the iterable. >>> list(powerset([1, 2, 3])) [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)] :func:`powerset` will operate on iterables that aren't :class:`set` instances, so repeated elements in the input will produce repeated elements in the output. Use :func:`unique_everseen` on the input to avoid generating duplicates: >>> seq = [1, 1, 0] >>> list(powerset(seq)) [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)] >>> from more_itertools import unique_everseen >>> list(powerset(unique_everseen(seq))) [(), (1,), (0,), (1, 0)] """ s = list(iterable) return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1)) def unique_everseen(iterable, key=None): """ Yield unique elements, preserving order. >>> list(unique_everseen('AAAABBBCCDAABBB')) ['A', 'B', 'C', 'D'] >>> list(unique_everseen('ABBCcAD', str.lower)) ['A', 'B', 'C', 'D'] Sequences with a mix of hashable and unhashable items can be used. The function will be slower (i.e., `O(n^2)`) for unhashable items. Remember that ``list`` objects are unhashable - you can use the *key* parameter to transform the list to a tuple (which is hashable) to avoid a slowdown. >>> iterable = ([1, 2], [2, 3], [1, 2]) >>> list(unique_everseen(iterable)) # Slow [[1, 2], [2, 3]] >>> list(unique_everseen(iterable, key=tuple)) # Faster [[1, 2], [2, 3]] Similary, you may want to convert unhashable ``set`` objects with ``key=frozenset``. For ``dict`` objects, ``key=lambda x: frozenset(x.items())`` can be used. """ seenset = set() seenset_add = seenset.add seenlist = [] seenlist_add = seenlist.append use_key = key is not None for element in iterable: k = key(element) if use_key else element try: if k not in seenset: seenset_add(k) yield element except TypeError: if k not in seenlist: seenlist_add(k) yield element def unique_justseen(iterable, key=None): """Yields elements in order, ignoring serial duplicates >>> list(unique_justseen('AAAABBBCCDAABBB')) ['A', 'B', 'C', 'D', 'A', 'B'] >>> list(unique_justseen('ABBCcAD', str.lower)) ['A', 'B', 'C', 'A', 'D'] """ return map(next, map(operator.itemgetter(1), groupby(iterable, key))) def iter_except(func, exception, first=None): """Yields results from a function repeatedly until an exception is raised. Converts a call-until-exception interface to an iterator interface. Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel to end the loop. >>> l = [0, 1, 2] >>> list(iter_except(l.pop, IndexError)) [2, 1, 0] Multiple exceptions can be specified as a stopping condition: >>> l = [1, 2, 3, '...', 4, 5, 6] >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) [7, 6, 5] >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) [4, 3, 2] >>> list(iter_except(lambda: 1 + l.pop(), (IndexError, TypeError))) [] """ try: if first is not None: yield first() while 1: yield func() except exception: pass def first_true(iterable, default=None, pred=None): """ Returns the first true value in the iterable. If no true value is found, returns *default* If *pred* is not None, returns the first item for which ``pred(item) == True`` . >>> first_true(range(10)) 1 >>> first_true(range(10), pred=lambda x: x > 5) 6 >>> first_true(range(10), default='missing', pred=lambda x: x > 9) 'missing' """ return next(filter(pred, iterable), default) def random_product(*args, repeat=1): """Draw an item at random from each of the input iterables. >>> random_product('abc', range(4), 'XYZ') # doctest:+SKIP ('c', 3, 'Z') If *repeat* is provided as a keyword argument, that many items will be drawn from each iterable. >>> random_product('abcd', range(4), repeat=2) # doctest:+SKIP ('a', 2, 'd', 3) This equivalent to taking a random selection from ``itertools.product(*args, **kwarg)``. """ pools = [tuple(pool) for pool in args] * repeat return tuple(choice(pool) for pool in pools) def random_permutation(iterable, r=None): """Return a random *r* length permutation of the elements in *iterable*. If *r* is not specified or is ``None``, then *r* defaults to the length of *iterable*. >>> random_permutation(range(5)) # doctest:+SKIP (3, 4, 0, 1, 2) This equivalent to taking a random selection from ``itertools.permutations(iterable, r)``. """ pool = tuple(iterable) r = len(pool) if r is None else r return tuple(sample(pool, r)) def random_combination(iterable, r): """Return a random *r* length subsequence of the elements in *iterable*. >>> random_combination(range(5), 3) # doctest:+SKIP (2, 3, 4) This equivalent to taking a random selection from ``itertools.combinations(iterable, r)``. """ pool = tuple(iterable) n = len(pool) indices = sorted(sample(range(n), r)) return tuple(pool[i] for i in indices) def random_combination_with_replacement(iterable, r): """Return a random *r* length subsequence of elements in *iterable*, allowing individual elements to be repeated. >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP (0, 0, 1, 2, 2) This equivalent to taking a random selection from ``itertools.combinations_with_replacement(iterable, r)``. """ pool = tuple(iterable) n = len(pool) indices = sorted(randrange(n) for i in range(r)) return tuple(pool[i] for i in indices) def nth_combination(iterable, r, index): """Equivalent to ``list(combinations(iterable, r))[index]``. The subsequences of *iterable* that are of length *r* can be ordered lexicographically. :func:`nth_combination` computes the subsequence at sort position *index* directly, without computing the previous subsequences. >>> nth_combination(range(5), 3, 5) (0, 3, 4) ``ValueError`` will be raised If *r* is negative or greater than the length of *iterable*. ``IndexError`` will be raised if the given *index* is invalid. """ pool = tuple(iterable) n = len(pool) if (r < 0) or (r > n): raise ValueError c = 1 k = min(r, n - r) for i in range(1, k + 1): c = c * (n - k + i) // i if index < 0: index += c if (index < 0) or (index >= c): raise IndexError result = [] while r: c, n, r = c * r // n, n - 1, r - 1 while index >= c: index -= c c, n = c * (n - r) // n, n - 1 result.append(pool[-1 - n]) return tuple(result) def prepend(value, iterator): """Yield *value*, followed by the elements in *iterator*. >>> value = '0' >>> iterator = ['1', '2', '3'] >>> list(prepend(value, iterator)) ['0', '1', '2', '3'] To prepend multiple values, see :func:`itertools.chain` or :func:`value_chain`. """ return chain([value], iterator) def convolve(signal, kernel): """Convolve the iterable *signal* with the iterable *kernel*. >>> signal = (1, 2, 3, 4, 5) >>> kernel = [3, 2, 1] >>> list(convolve(signal, kernel)) [3, 8, 14, 20, 26, 14, 5] Note: the input arguments are not interchangeable, as the *kernel* is immediately consumed and stored. """ kernel = tuple(kernel)[::-1] n = len(kernel) window = deque([0], maxlen=n) * n for x in chain(signal, repeat(0, n - 1)): window.append(x) yield sum(map(operator.mul, kernel, window)) def before_and_after(predicate, it): """A variant of :func:`takewhile` that allows complete access to the remainder of the iterator. >>> it = iter('ABCdEfGhI') >>> all_upper, remainder = before_and_after(str.isupper, it) >>> ''.join(all_upper) 'ABC' >>> ''.join(remainder) # takewhile() would lose the 'd' 'dEfGhI' Note that the first iterator must be fully consumed before the second iterator can generate valid results. """ it = iter(it) transition = [] def true_iterator(): for elem in it: if predicate(elem): yield elem else: transition.append(elem) return # Note: this is different from itertools recipes to allow nesting # before_and_after remainders into before_and_after again. See tests # for an example. remainder_iterator = chain(transition, it) return true_iterator(), remainder_iterator def triplewise(iterable): """Return overlapping triplets from *iterable*. >>> list(triplewise('ABCDE')) [('A', 'B', 'C'), ('B', 'C', 'D'), ('C', 'D', 'E')] """ for (a, _), (b, c) in pairwise(pairwise(iterable)): yield a, b, c def sliding_window(iterable, n): """Return a sliding window of width *n* over *iterable*. >>> list(sliding_window(range(6), 4)) [(0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5)] If *iterable* has fewer than *n* items, then nothing is yielded: >>> list(sliding_window(range(3), 4)) [] For a variant with more features, see :func:`windowed`. """ it = iter(iterable) window = deque(islice(it, n), maxlen=n) if len(window) == n: yield tuple(window) for x in it: window.append(x) yield tuple(window) def subslices(iterable): """Return all contiguous non-empty subslices of *iterable*. >>> list(subslices('ABC')) [['A'], ['A', 'B'], ['A', 'B', 'C'], ['B'], ['B', 'C'], ['C']] This is similar to :func:`substrings`, but emits items in a different order. """ seq = list(iterable) slices = starmap(slice, combinations(range(len(seq) + 1), 2)) return map(operator.getitem, repeat(seq), slices) def polynomial_from_roots(roots): """Compute a polynomial's coefficients from its roots. >>> roots = [5, -4, 3] # (x - 5) * (x + 4) * (x - 3) >>> polynomial_from_roots(roots) # x^3 - 4 * x^2 - 17 * x + 60 [1, -4, -17, 60] """ # Use math.prod for Python 3.8+, prod = getattr(math, 'prod', lambda x: reduce(operator.mul, x, 1)) roots = list(map(operator.neg, roots)) return [ sum(map(prod, combinations(roots, k))) for k in range(len(roots) + 1) ] def iter_index(iterable, value, start=0): """Yield the index of each place in *iterable* that *value* occurs, beginning with index *start*. See :func:`locate` for a more general means of finding the indexes associated with particular values. >>> list(iter_index('AABCADEAF', 'A')) [0, 1, 4, 7] """ try: seq_index = iterable.index except AttributeError: # Slow path for general iterables it = islice(iterable, start, None) for i, element in enumerate(it, start): if element is value or element == value: yield i else: # Fast path for sequences i = start - 1 try: while True: i = seq_index(value, i + 1) yield i except ValueError: pass def sieve(n): """Yield the primes less than n. >>> list(sieve(30)) [2, 3, 5, 7, 11, 13, 17, 19, 23, 29] """ isqrt = getattr(math, 'isqrt', lambda x: int(math.sqrt(x))) data = bytearray((0, 1)) * (n // 2) data[:3] = 0, 0, 0 limit = isqrt(n) + 1 for p in compress(range(limit), data): data[p * p : n : p + p] = bytes(len(range(p * p, n, p + p))) data[2] = 1 return iter_index(data, 1) if n > 2 else iter([]) def batched(iterable, n): """Batch data into lists of length *n*. The last batch may be shorter. >>> list(batched('ABCDEFG', 3)) [['A', 'B', 'C'], ['D', 'E', 'F'], ['G']] This recipe is from the ``itertools`` docs. This library also provides :func:`chunked`, which has a different implementation. """ if hexversion >= 0x30C00A0: # Python 3.12.0a0 warnings.warn( ( 'batched will be removed in a future version of ' 'more-itertools. Use the standard library ' 'itertools.batched function instead' ), DeprecationWarning, ) it = iter(iterable) while True: batch = list(islice(it, n)) if not batch: break yield batch def transpose(it): """Swap the rows and columns of the input. >>> list(transpose([(1, 2, 3), (11, 22, 33)])) [(1, 11), (2, 22), (3, 33)] The caller should ensure that the dimensions of the input are compatible. """ # TODO: when 3.9 goes end-of-life, add stric=True to this. return zip(*it) def matmul(m1, m2): """Multiply two matrices. >>> list(matmul([(7, 5), (3, 5)], [(2, 5), (7, 9)])) [[49, 80], [41, 60]] The caller should ensure that the dimensions of the input matrices are compatible with each other. """ n = len(m2[0]) return batched(starmap(dotproduct, product(m1, transpose(m2))), n) def factor(n): """Yield the prime factors of n. >>> list(factor(360)) [2, 2, 2, 3, 3, 5] """ isqrt = getattr(math, 'isqrt', lambda x: int(math.sqrt(x))) for prime in sieve(isqrt(n) + 1): while True: quotient, remainder = divmod(n, prime) if remainder: break yield prime n = quotient if n == 1: return if n >= 2: yield n ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4995484 setuptools-68.1.2/pkg_resources/_vendor/packaging/0000755000175100001730000000000014467657443021711 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/__init__.py0000644000175100001730000000076514467657412024026 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. __title__ = "packaging" __summary__ = "Core utilities for Python packages" __uri__ = "https://github.com/pypa/packaging" __version__ = "23.1" __author__ = "Donald Stufft and individual contributors" __email__ = "donald@stufft.io" __license__ = "BSD-2-Clause or Apache-2.0" __copyright__ = "2014-2019 %s" % __author__ ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/_elffile.py0000644000175100001730000000630214467657412024025 0ustar00runnerdocker""" ELF file parser. This provides a class ``ELFFile`` that parses an ELF executable in a similar interface to ``ZipFile``. Only the read interface is implemented. Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html """ import enum import os import struct from typing import IO, Optional, Tuple class ELFInvalid(ValueError): pass class EIClass(enum.IntEnum): C32 = 1 C64 = 2 class EIData(enum.IntEnum): Lsb = 1 Msb = 2 class EMachine(enum.IntEnum): I386 = 3 S390 = 22 Arm = 40 X8664 = 62 AArc64 = 183 class ELFFile: """ Representation of an ELF executable. """ def __init__(self, f: IO[bytes]) -> None: self._f = f try: ident = self._read("16B") except struct.error: raise ELFInvalid("unable to parse identification") magic = bytes(ident[:4]) if magic != b"\x7fELF": raise ELFInvalid(f"invalid magic: {magic!r}") self.capacity = ident[4] # Format for program header (bitness). self.encoding = ident[5] # Data structure encoding (endianness). try: # e_fmt: Format for program header. # p_fmt: Format for section header. # p_idx: Indexes to find p_type, p_offset, and p_filesz. e_fmt, self._p_fmt, self._p_idx = { (1, 1): ("HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)), # 32-bit MSB. (2, 1): ("HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)), # 64-bit MSB. }[(self.capacity, self.encoding)] except KeyError: raise ELFInvalid( f"unrecognized capacity ({self.capacity}) or " f"encoding ({self.encoding})" ) try: ( _, self.machine, # Architecture type. _, _, self._e_phoff, # Offset of program header. _, self.flags, # Processor-specific flags. _, self._e_phentsize, # Size of section. self._e_phnum, # Number of sections. ) = self._read(e_fmt) except struct.error as e: raise ELFInvalid("unable to parse machine and section information") from e def _read(self, fmt: str) -> Tuple[int, ...]: return struct.unpack(fmt, self._f.read(struct.calcsize(fmt))) @property def interpreter(self) -> Optional[str]: """ The path recorded in the ``PT_INTERP`` section header. """ for index in range(self._e_phnum): self._f.seek(self._e_phoff + self._e_phentsize * index) try: data = self._read(self._p_fmt) except struct.error: continue if data[self._p_idx[0]] != 3: # Not PT_INTERP. continue self._f.seek(data[self._p_idx[1]]) return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0") return None ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/_manylinux.py0000644000175100001730000002133614467657412024447 0ustar00runnerdockerimport collections import contextlib import functools import os import re import sys import warnings from typing import Dict, Generator, Iterator, NamedTuple, Optional, Tuple from ._elffile import EIClass, EIData, ELFFile, EMachine EF_ARM_ABIMASK = 0xFF000000 EF_ARM_ABI_VER5 = 0x05000000 EF_ARM_ABI_FLOAT_HARD = 0x00000400 # `os.PathLike` not a generic type until Python 3.9, so sticking with `str` # as the type for `path` until then. @contextlib.contextmanager def _parse_elf(path: str) -> Generator[Optional[ELFFile], None, None]: try: with open(path, "rb") as f: yield ELFFile(f) except (OSError, TypeError, ValueError): yield None def _is_linux_armhf(executable: str) -> bool: # hard-float ABI can be detected from the ELF header of the running # process # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf with _parse_elf(executable) as f: return ( f is not None and f.capacity == EIClass.C32 and f.encoding == EIData.Lsb and f.machine == EMachine.Arm and f.flags & EF_ARM_ABIMASK == EF_ARM_ABI_VER5 and f.flags & EF_ARM_ABI_FLOAT_HARD == EF_ARM_ABI_FLOAT_HARD ) def _is_linux_i686(executable: str) -> bool: with _parse_elf(executable) as f: return ( f is not None and f.capacity == EIClass.C32 and f.encoding == EIData.Lsb and f.machine == EMachine.I386 ) def _have_compatible_abi(executable: str, arch: str) -> bool: if arch == "armv7l": return _is_linux_armhf(executable) if arch == "i686": return _is_linux_i686(executable) return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"} # If glibc ever changes its major version, we need to know what the last # minor version was, so we can build the complete list of all versions. # For now, guess what the highest minor version might be, assume it will # be 50 for testing. Once this actually happens, update the dictionary # with the actual value. _LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50) class _GLibCVersion(NamedTuple): major: int minor: int def _glibc_version_string_confstr() -> Optional[str]: """ Primary implementation of glibc_version_string using os.confstr. """ # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely # to be broken or missing. This strategy is used in the standard library # platform module. # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183 try: # Should be a string like "glibc 2.17". version_string: str = getattr(os, "confstr")("CS_GNU_LIBC_VERSION") assert version_string is not None _, version = version_string.rsplit() except (AssertionError, AttributeError, OSError, ValueError): # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)... return None return version def _glibc_version_string_ctypes() -> Optional[str]: """ Fallback implementation of glibc_version_string using ctypes. """ try: import ctypes except ImportError: return None # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen # manpage says, "If filename is NULL, then the returned handle is for the # main program". This way we can let the linker do the work to figure out # which libc our process is actually using. # # We must also handle the special case where the executable is not a # dynamically linked executable. This can occur when using musl libc, # for example. In this situation, dlopen() will error, leading to an # OSError. Interestingly, at least in the case of musl, there is no # errno set on the OSError. The single string argument used to construct # OSError comes from libc itself and is therefore not portable to # hard code here. In any case, failure to call dlopen() means we # can proceed, so we bail on our attempt. try: process_namespace = ctypes.CDLL(None) except OSError: return None try: gnu_get_libc_version = process_namespace.gnu_get_libc_version except AttributeError: # Symbol doesn't exist -> therefore, we are not linked to # glibc. return None # Call gnu_get_libc_version, which returns a string like "2.5" gnu_get_libc_version.restype = ctypes.c_char_p version_str: str = gnu_get_libc_version() # py2 / py3 compatibility: if not isinstance(version_str, str): version_str = version_str.decode("ascii") return version_str def _glibc_version_string() -> Optional[str]: """Returns glibc version string, or None if not using glibc.""" return _glibc_version_string_confstr() or _glibc_version_string_ctypes() def _parse_glibc_version(version_str: str) -> Tuple[int, int]: """Parse glibc version. We use a regexp instead of str.split because we want to discard any random junk that might come after the minor version -- this might happen in patched/forked versions of glibc (e.g. Linaro's version of glibc uses version strings like "2.20-2014.11"). See gh-3588. """ m = re.match(r"(?P[0-9]+)\.(?P[0-9]+)", version_str) if not m: warnings.warn( f"Expected glibc version with 2 components major.minor," f" got: {version_str}", RuntimeWarning, ) return -1, -1 return int(m.group("major")), int(m.group("minor")) @functools.lru_cache() def _get_glibc_version() -> Tuple[int, int]: version_str = _glibc_version_string() if version_str is None: return (-1, -1) return _parse_glibc_version(version_str) # From PEP 513, PEP 600 def _is_compatible(name: str, arch: str, version: _GLibCVersion) -> bool: sys_glibc = _get_glibc_version() if sys_glibc < version: return False # Check for presence of _manylinux module. try: import _manylinux # noqa except ImportError: return True if hasattr(_manylinux, "manylinux_compatible"): result = _manylinux.manylinux_compatible(version[0], version[1], arch) if result is not None: return bool(result) return True if version == _GLibCVersion(2, 5): if hasattr(_manylinux, "manylinux1_compatible"): return bool(_manylinux.manylinux1_compatible) if version == _GLibCVersion(2, 12): if hasattr(_manylinux, "manylinux2010_compatible"): return bool(_manylinux.manylinux2010_compatible) if version == _GLibCVersion(2, 17): if hasattr(_manylinux, "manylinux2014_compatible"): return bool(_manylinux.manylinux2014_compatible) return True _LEGACY_MANYLINUX_MAP = { # CentOS 7 w/ glibc 2.17 (PEP 599) (2, 17): "manylinux2014", # CentOS 6 w/ glibc 2.12 (PEP 571) (2, 12): "manylinux2010", # CentOS 5 w/ glibc 2.5 (PEP 513) (2, 5): "manylinux1", } def platform_tags(linux: str, arch: str) -> Iterator[str]: if not _have_compatible_abi(sys.executable, arch): return # Oldest glibc to be supported regardless of architecture is (2, 17). too_old_glibc2 = _GLibCVersion(2, 16) if arch in {"x86_64", "i686"}: # On x86/i686 also oldest glibc to be supported is (2, 5). too_old_glibc2 = _GLibCVersion(2, 4) current_glibc = _GLibCVersion(*_get_glibc_version()) glibc_max_list = [current_glibc] # We can assume compatibility across glibc major versions. # https://sourceware.org/bugzilla/show_bug.cgi?id=24636 # # Build a list of maximum glibc versions so that we can # output the canonical list of all glibc from current_glibc # down to too_old_glibc2, including all intermediary versions. for glibc_major in range(current_glibc.major - 1, 1, -1): glibc_minor = _LAST_GLIBC_MINOR[glibc_major] glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor)) for glibc_max in glibc_max_list: if glibc_max.major == too_old_glibc2.major: min_minor = too_old_glibc2.minor else: # For other glibc major versions oldest supported is (x, 0). min_minor = -1 for glibc_minor in range(glibc_max.minor, min_minor, -1): glibc_version = _GLibCVersion(glibc_max.major, glibc_minor) tag = "manylinux_{}_{}".format(*glibc_version) if _is_compatible(tag, arch, glibc_version): yield linux.replace("linux", tag) # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags. if glibc_version in _LEGACY_MANYLINUX_MAP: legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version] if _is_compatible(legacy_tag, arch, glibc_version): yield linux.replace("linux", legacy_tag) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/_musllinux.py0000644000175100001730000000473414467657412024466 0ustar00runnerdocker"""PEP 656 support. This module implements logic to detect if the currently running Python is linked against musl, and what musl version is used. """ import functools import re import subprocess import sys from typing import Iterator, NamedTuple, Optional from ._elffile import ELFFile class _MuslVersion(NamedTuple): major: int minor: int def _parse_musl_version(output: str) -> Optional[_MuslVersion]: lines = [n for n in (n.strip() for n in output.splitlines()) if n] if len(lines) < 2 or lines[0][:4] != "musl": return None m = re.match(r"Version (\d+)\.(\d+)", lines[1]) if not m: return None return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2))) @functools.lru_cache() def _get_musl_version(executable: str) -> Optional[_MuslVersion]: """Detect currently-running musl runtime version. This is done by checking the specified executable's dynamic linking information, and invoking the loader to parse its output for a version string. If the loader is musl, the output would be something like:: musl libc (x86_64) Version 1.2.2 Dynamic Program Loader """ try: with open(executable, "rb") as f: ld = ELFFile(f).interpreter except (OSError, TypeError, ValueError): return None if ld is None or "musl" not in ld: return None proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True) return _parse_musl_version(proc.stderr) def platform_tags(arch: str) -> Iterator[str]: """Generate musllinux tags compatible to the current platform. :param arch: Should be the part of platform tag after the ``linux_`` prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a prerequisite for the current platform to be musllinux-compatible. :returns: An iterator of compatible musllinux tags. """ sys_musl = _get_musl_version(sys.executable) if sys_musl is None: # Python not dynamically linked against musl. return for minor in range(sys_musl.minor, -1, -1): yield f"musllinux_{sys_musl.major}_{minor}_{arch}" if __name__ == "__main__": # pragma: no cover import sysconfig plat = sysconfig.get_platform() assert plat.startswith("linux-"), "not linux" print("plat:", plat) print("musl:", _get_musl_version(sys.executable)) print("tags:", end=" ") for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])): print(t, end="\n ") ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/_parser.py0000644000175100001730000002372214467657412023720 0ustar00runnerdocker"""Handwritten parser of dependency specifiers. The docstring for each __parse_* function contains ENBF-inspired grammar representing the implementation. """ import ast from typing import Any, List, NamedTuple, Optional, Tuple, Union from ._tokenizer import DEFAULT_RULES, Tokenizer class Node: def __init__(self, value: str) -> None: self.value = value def __str__(self) -> str: return self.value def __repr__(self) -> str: return f"<{self.__class__.__name__}('{self}')>" def serialize(self) -> str: raise NotImplementedError class Variable(Node): def serialize(self) -> str: return str(self) class Value(Node): def serialize(self) -> str: return f'"{self}"' class Op(Node): def serialize(self) -> str: return str(self) MarkerVar = Union[Variable, Value] MarkerItem = Tuple[MarkerVar, Op, MarkerVar] # MarkerAtom = Union[MarkerItem, List["MarkerAtom"]] # MarkerList = List[Union["MarkerList", MarkerAtom, str]] # mypy does not support recursive type definition # https://github.com/python/mypy/issues/731 MarkerAtom = Any MarkerList = List[Any] class ParsedRequirement(NamedTuple): name: str url: str extras: List[str] specifier: str marker: Optional[MarkerList] # -------------------------------------------------------------------------------------- # Recursive descent parser for dependency specifier # -------------------------------------------------------------------------------------- def parse_requirement(source: str) -> ParsedRequirement: return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES)) def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement: """ requirement = WS? IDENTIFIER WS? extras WS? requirement_details """ tokenizer.consume("WS") name_token = tokenizer.expect( "IDENTIFIER", expected="package name at the start of dependency specifier" ) name = name_token.text tokenizer.consume("WS") extras = _parse_extras(tokenizer) tokenizer.consume("WS") url, specifier, marker = _parse_requirement_details(tokenizer) tokenizer.expect("END", expected="end of dependency specifier") return ParsedRequirement(name, url, extras, specifier, marker) def _parse_requirement_details( tokenizer: Tokenizer, ) -> Tuple[str, str, Optional[MarkerList]]: """ requirement_details = AT URL (WS requirement_marker?)? | specifier WS? (requirement_marker)? """ specifier = "" url = "" marker = None if tokenizer.check("AT"): tokenizer.read() tokenizer.consume("WS") url_start = tokenizer.position url = tokenizer.expect("URL", expected="URL after @").text if tokenizer.check("END", peek=True): return (url, specifier, marker) tokenizer.expect("WS", expected="whitespace after URL") # The input might end after whitespace. if tokenizer.check("END", peek=True): return (url, specifier, marker) marker = _parse_requirement_marker( tokenizer, span_start=url_start, after="URL and whitespace" ) else: specifier_start = tokenizer.position specifier = _parse_specifier(tokenizer) tokenizer.consume("WS") if tokenizer.check("END", peek=True): return (url, specifier, marker) marker = _parse_requirement_marker( tokenizer, span_start=specifier_start, after=( "version specifier" if specifier else "name and no valid version specifier" ), ) return (url, specifier, marker) def _parse_requirement_marker( tokenizer: Tokenizer, *, span_start: int, after: str ) -> MarkerList: """ requirement_marker = SEMICOLON marker WS? """ if not tokenizer.check("SEMICOLON"): tokenizer.raise_syntax_error( f"Expected end or semicolon (after {after})", span_start=span_start, ) tokenizer.read() marker = _parse_marker(tokenizer) tokenizer.consume("WS") return marker def _parse_extras(tokenizer: Tokenizer) -> List[str]: """ extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)? """ if not tokenizer.check("LEFT_BRACKET", peek=True): return [] with tokenizer.enclosing_tokens( "LEFT_BRACKET", "RIGHT_BRACKET", around="extras", ): tokenizer.consume("WS") extras = _parse_extras_list(tokenizer) tokenizer.consume("WS") return extras def _parse_extras_list(tokenizer: Tokenizer) -> List[str]: """ extras_list = identifier (wsp* ',' wsp* identifier)* """ extras: List[str] = [] if not tokenizer.check("IDENTIFIER"): return extras extras.append(tokenizer.read().text) while True: tokenizer.consume("WS") if tokenizer.check("IDENTIFIER", peek=True): tokenizer.raise_syntax_error("Expected comma between extra names") elif not tokenizer.check("COMMA"): break tokenizer.read() tokenizer.consume("WS") extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma") extras.append(extra_token.text) return extras def _parse_specifier(tokenizer: Tokenizer) -> str: """ specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS | WS? version_many WS? """ with tokenizer.enclosing_tokens( "LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", around="version specifier", ): tokenizer.consume("WS") parsed_specifiers = _parse_version_many(tokenizer) tokenizer.consume("WS") return parsed_specifiers def _parse_version_many(tokenizer: Tokenizer) -> str: """ version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)? """ parsed_specifiers = "" while tokenizer.check("SPECIFIER"): span_start = tokenizer.position parsed_specifiers += tokenizer.read().text if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True): tokenizer.raise_syntax_error( ".* suffix can only be used with `==` or `!=` operators", span_start=span_start, span_end=tokenizer.position + 1, ) if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True): tokenizer.raise_syntax_error( "Local version label can only be used with `==` or `!=` operators", span_start=span_start, span_end=tokenizer.position, ) tokenizer.consume("WS") if not tokenizer.check("COMMA"): break parsed_specifiers += tokenizer.read().text tokenizer.consume("WS") return parsed_specifiers # -------------------------------------------------------------------------------------- # Recursive descent parser for marker expression # -------------------------------------------------------------------------------------- def parse_marker(source: str) -> MarkerList: return _parse_marker(Tokenizer(source, rules=DEFAULT_RULES)) def _parse_marker(tokenizer: Tokenizer) -> MarkerList: """ marker = marker_atom (BOOLOP marker_atom)+ """ expression = [_parse_marker_atom(tokenizer)] while tokenizer.check("BOOLOP"): token = tokenizer.read() expr_right = _parse_marker_atom(tokenizer) expression.extend((token.text, expr_right)) return expression def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom: """ marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS? | WS? marker_item WS? """ tokenizer.consume("WS") if tokenizer.check("LEFT_PARENTHESIS", peek=True): with tokenizer.enclosing_tokens( "LEFT_PARENTHESIS", "RIGHT_PARENTHESIS", around="marker expression", ): tokenizer.consume("WS") marker: MarkerAtom = _parse_marker(tokenizer) tokenizer.consume("WS") else: marker = _parse_marker_item(tokenizer) tokenizer.consume("WS") return marker def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem: """ marker_item = WS? marker_var WS? marker_op WS? marker_var WS? """ tokenizer.consume("WS") marker_var_left = _parse_marker_var(tokenizer) tokenizer.consume("WS") marker_op = _parse_marker_op(tokenizer) tokenizer.consume("WS") marker_var_right = _parse_marker_var(tokenizer) tokenizer.consume("WS") return (marker_var_left, marker_op, marker_var_right) def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar: """ marker_var = VARIABLE | QUOTED_STRING """ if tokenizer.check("VARIABLE"): return process_env_var(tokenizer.read().text.replace(".", "_")) elif tokenizer.check("QUOTED_STRING"): return process_python_str(tokenizer.read().text) else: tokenizer.raise_syntax_error( message="Expected a marker variable or quoted string" ) def process_env_var(env_var: str) -> Variable: if ( env_var == "platform_python_implementation" or env_var == "python_implementation" ): return Variable("platform_python_implementation") else: return Variable(env_var) def process_python_str(python_str: str) -> Value: value = ast.literal_eval(python_str) return Value(str(value)) def _parse_marker_op(tokenizer: Tokenizer) -> Op: """ marker_op = IN | NOT IN | OP """ if tokenizer.check("IN"): tokenizer.read() return Op("in") elif tokenizer.check("NOT"): tokenizer.read() tokenizer.expect("WS", expected="whitespace after 'not'") tokenizer.expect("IN", expected="'in' after 'not'") return Op("not in") elif tokenizer.check("OP"): return Op(tokenizer.read().text) else: return tokenizer.raise_syntax_error( "Expected marker operator, one of " "<=, <, !=, ==, >=, >, ~=, ===, in, not in" ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/_structures.py0000644000175100001730000000262714467657412024650 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. class InfinityType: def __repr__(self) -> str: return "Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return False def __le__(self, other: object) -> bool: return False def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return True def __ge__(self, other: object) -> bool: return True def __neg__(self: object) -> "NegativeInfinityType": return NegativeInfinity Infinity = InfinityType() class NegativeInfinityType: def __repr__(self) -> str: return "-Infinity" def __hash__(self) -> int: return hash(repr(self)) def __lt__(self, other: object) -> bool: return True def __le__(self, other: object) -> bool: return True def __eq__(self, other: object) -> bool: return isinstance(other, self.__class__) def __gt__(self, other: object) -> bool: return False def __ge__(self, other: object) -> bool: return False def __neg__(self: object) -> InfinityType: return Infinity NegativeInfinity = NegativeInfinityType() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/_tokenizer.py0000644000175100001730000001225414467657412024434 0ustar00runnerdockerimport contextlib import re from dataclasses import dataclass from typing import Dict, Iterator, NoReturn, Optional, Tuple, Union from .specifiers import Specifier @dataclass class Token: name: str text: str position: int class ParserSyntaxError(Exception): """The provided source text could not be parsed correctly.""" def __init__( self, message: str, *, source: str, span: Tuple[int, int], ) -> None: self.span = span self.message = message self.source = source super().__init__() def __str__(self) -> str: marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^" return "\n ".join([self.message, self.source, marker]) DEFAULT_RULES: "Dict[str, Union[str, re.Pattern[str]]]" = { "LEFT_PARENTHESIS": r"\(", "RIGHT_PARENTHESIS": r"\)", "LEFT_BRACKET": r"\[", "RIGHT_BRACKET": r"\]", "SEMICOLON": r";", "COMMA": r",", "QUOTED_STRING": re.compile( r""" ( ('[^']*') | ("[^"]*") ) """, re.VERBOSE, ), "OP": r"(===|==|~=|!=|<=|>=|<|>)", "BOOLOP": r"\b(or|and)\b", "IN": r"\bin\b", "NOT": r"\bnot\b", "VARIABLE": re.compile( r""" \b( python_version |python_full_version |os[._]name |sys[._]platform |platform_(release|system) |platform[._](version|machine|python_implementation) |python_implementation |implementation_(name|version) |extra )\b """, re.VERBOSE, ), "SPECIFIER": re.compile( Specifier._operator_regex_str + Specifier._version_regex_str, re.VERBOSE | re.IGNORECASE, ), "AT": r"\@", "URL": r"[^ \t]+", "IDENTIFIER": r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b", "VERSION_PREFIX_TRAIL": r"\.\*", "VERSION_LOCAL_LABEL_TRAIL": r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*", "WS": r"[ \t]+", "END": r"$", } class Tokenizer: """Context-sensitive token parsing. Provides methods to examine the input stream to check whether the next token matches. """ def __init__( self, source: str, *, rules: "Dict[str, Union[str, re.Pattern[str]]]", ) -> None: self.source = source self.rules: Dict[str, re.Pattern[str]] = { name: re.compile(pattern) for name, pattern in rules.items() } self.next_token: Optional[Token] = None self.position = 0 def consume(self, name: str) -> None: """Move beyond provided token name, if at current position.""" if self.check(name): self.read() def check(self, name: str, *, peek: bool = False) -> bool: """Check whether the next token has the provided name. By default, if the check succeeds, the token *must* be read before another check. If `peek` is set to `True`, the token is not loaded and would need to be checked again. """ assert ( self.next_token is None ), f"Cannot check for {name!r}, already have {self.next_token!r}" assert name in self.rules, f"Unknown token name: {name!r}" expression = self.rules[name] match = expression.match(self.source, self.position) if match is None: return False if not peek: self.next_token = Token(name, match[0], self.position) return True def expect(self, name: str, *, expected: str) -> Token: """Expect a certain token name next, failing with a syntax error otherwise. The token is *not* read. """ if not self.check(name): raise self.raise_syntax_error(f"Expected {expected}") return self.read() def read(self) -> Token: """Consume the next token and return it.""" token = self.next_token assert token is not None self.position += len(token.text) self.next_token = None return token def raise_syntax_error( self, message: str, *, span_start: Optional[int] = None, span_end: Optional[int] = None, ) -> NoReturn: """Raise ParserSyntaxError at the given position.""" span = ( self.position if span_start is None else span_start, self.position if span_end is None else span_end, ) raise ParserSyntaxError( message, source=self.source, span=span, ) @contextlib.contextmanager def enclosing_tokens( self, open_token: str, close_token: str, *, around: str ) -> Iterator[None]: if self.check(open_token): open_position = self.position self.read() else: open_position = None yield if open_position is None: return if not self.check(close_token): self.raise_syntax_error( f"Expected matching {close_token} for {open_token}, after {around}", span_start=open_position, ) self.read() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/markers.py0000644000175100001730000002002014467657412023715 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import operator import os import platform import sys from typing import Any, Callable, Dict, List, Optional, Tuple, Union from ._parser import ( MarkerAtom, MarkerList, Op, Value, Variable, parse_marker as _parse_marker, ) from ._tokenizer import ParserSyntaxError from .specifiers import InvalidSpecifier, Specifier from .utils import canonicalize_name __all__ = [ "InvalidMarker", "UndefinedComparison", "UndefinedEnvironmentName", "Marker", "default_environment", ] Operator = Callable[[str, str], bool] class InvalidMarker(ValueError): """ An invalid marker was found, users should refer to PEP 508. """ class UndefinedComparison(ValueError): """ An invalid operation was attempted on a value that doesn't support it. """ class UndefinedEnvironmentName(ValueError): """ A name was attempted to be used that does not exist inside of the environment. """ def _normalize_extra_values(results: Any) -> Any: """ Normalize extra values. """ if isinstance(results[0], tuple): lhs, op, rhs = results[0] if isinstance(lhs, Variable) and lhs.value == "extra": normalized_extra = canonicalize_name(rhs.value) rhs = Value(normalized_extra) elif isinstance(rhs, Variable) and rhs.value == "extra": normalized_extra = canonicalize_name(lhs.value) lhs = Value(normalized_extra) results[0] = lhs, op, rhs return results def _format_marker( marker: Union[List[str], MarkerAtom, str], first: Optional[bool] = True ) -> str: assert isinstance(marker, (list, tuple, str)) # Sometimes we have a structure like [[...]] which is a single item list # where the single item is itself it's own list. In that case we want skip # the rest of this function so that we don't get extraneous () on the # outside. if ( isinstance(marker, list) and len(marker) == 1 and isinstance(marker[0], (list, tuple)) ): return _format_marker(marker[0]) if isinstance(marker, list): inner = (_format_marker(m, first=False) for m in marker) if first: return " ".join(inner) else: return "(" + " ".join(inner) + ")" elif isinstance(marker, tuple): return " ".join([m.serialize() for m in marker]) else: return marker _operators: Dict[str, Operator] = { "in": lambda lhs, rhs: lhs in rhs, "not in": lambda lhs, rhs: lhs not in rhs, "<": operator.lt, "<=": operator.le, "==": operator.eq, "!=": operator.ne, ">=": operator.ge, ">": operator.gt, } def _eval_op(lhs: str, op: Op, rhs: str) -> bool: try: spec = Specifier("".join([op.serialize(), rhs])) except InvalidSpecifier: pass else: return spec.contains(lhs, prereleases=True) oper: Optional[Operator] = _operators.get(op.serialize()) if oper is None: raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.") return oper(lhs, rhs) def _normalize(*values: str, key: str) -> Tuple[str, ...]: # PEP 685 – Comparison of extra names for optional distribution dependencies # https://peps.python.org/pep-0685/ # > When comparing extra names, tools MUST normalize the names being # > compared using the semantics outlined in PEP 503 for names if key == "extra": return tuple(canonicalize_name(v) for v in values) # other environment markers don't have such standards return values def _evaluate_markers(markers: MarkerList, environment: Dict[str, str]) -> bool: groups: List[List[bool]] = [[]] for marker in markers: assert isinstance(marker, (list, tuple, str)) if isinstance(marker, list): groups[-1].append(_evaluate_markers(marker, environment)) elif isinstance(marker, tuple): lhs, op, rhs = marker if isinstance(lhs, Variable): environment_key = lhs.value lhs_value = environment[environment_key] rhs_value = rhs.value else: lhs_value = lhs.value environment_key = rhs.value rhs_value = environment[environment_key] lhs_value, rhs_value = _normalize(lhs_value, rhs_value, key=environment_key) groups[-1].append(_eval_op(lhs_value, op, rhs_value)) else: assert marker in ["and", "or"] if marker == "or": groups.append([]) return any(all(item) for item in groups) def format_full_version(info: "sys._version_info") -> str: version = "{0.major}.{0.minor}.{0.micro}".format(info) kind = info.releaselevel if kind != "final": version += kind[0] + str(info.serial) return version def default_environment() -> Dict[str, str]: iver = format_full_version(sys.implementation.version) implementation_name = sys.implementation.name return { "implementation_name": implementation_name, "implementation_version": iver, "os_name": os.name, "platform_machine": platform.machine(), "platform_release": platform.release(), "platform_system": platform.system(), "platform_version": platform.version(), "python_full_version": platform.python_version(), "platform_python_implementation": platform.python_implementation(), "python_version": ".".join(platform.python_version_tuple()[:2]), "sys_platform": sys.platform, } class Marker: def __init__(self, marker: str) -> None: # Note: We create a Marker object without calling this constructor in # packaging.requirements.Requirement. If any additional logic is # added here, make sure to mirror/adapt Requirement. try: self._markers = _normalize_extra_values(_parse_marker(marker)) # The attribute `_markers` can be described in terms of a recursive type: # MarkerList = List[Union[Tuple[Node, ...], str, MarkerList]] # # For example, the following expression: # python_version > "3.6" or (python_version == "3.6" and os_name == "unix") # # is parsed into: # [ # (, ')>, ), # 'and', # [ # (, , ), # 'or', # (, , ) # ] # ] except ParserSyntaxError as e: raise InvalidMarker(str(e)) from e def __str__(self) -> str: return _format_marker(self._markers) def __repr__(self) -> str: return f"" def __hash__(self) -> int: return hash((self.__class__.__name__, str(self))) def __eq__(self, other: Any) -> bool: if not isinstance(other, Marker): return NotImplemented return str(self) == str(other) def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool: """Evaluate a marker. Return the boolean from evaluating the given marker against the environment. environment is an optional argument to override all or part of the determined environment. The environment is determined from the current Python process. """ current_environment = default_environment() current_environment["extra"] = "" if environment is not None: current_environment.update(environment) # The API used to allow setting extra to None. We need to handle this # case for backwards compatibility. if current_environment["extra"] is None: current_environment["extra"] = "" return _evaluate_markers(self._markers, current_environment) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/metadata.py0000644000175100001730000004001514467657412024037 0ustar00runnerdockerimport email.feedparser import email.header import email.message import email.parser import email.policy import sys import typing from typing import Dict, List, Optional, Tuple, Union, cast if sys.version_info >= (3, 8): # pragma: no cover from typing import TypedDict else: # pragma: no cover if typing.TYPE_CHECKING: from typing_extensions import TypedDict else: try: from typing_extensions import TypedDict except ImportError: class TypedDict: def __init_subclass__(*_args, **_kwargs): pass # The RawMetadata class attempts to make as few assumptions about the underlying # serialization formats as possible. The idea is that as long as a serialization # formats offer some very basic primitives in *some* way then we can support # serializing to and from that format. class RawMetadata(TypedDict, total=False): """A dictionary of raw core metadata. Each field in core metadata maps to a key of this dictionary (when data is provided). The key is lower-case and underscores are used instead of dashes compared to the equivalent core metadata field. Any core metadata field that can be specified multiple times or can hold multiple values in a single field have a key with a plural name. Core metadata fields that can be specified multiple times are stored as a list or dict depending on which is appropriate for the field. Any fields which hold multiple values in a single field are stored as a list. """ # Metadata 1.0 - PEP 241 metadata_version: str name: str version: str platforms: List[str] summary: str description: str keywords: List[str] home_page: str author: str author_email: str license: str # Metadata 1.1 - PEP 314 supported_platforms: List[str] download_url: str classifiers: List[str] requires: List[str] provides: List[str] obsoletes: List[str] # Metadata 1.2 - PEP 345 maintainer: str maintainer_email: str requires_dist: List[str] provides_dist: List[str] obsoletes_dist: List[str] requires_python: str requires_external: List[str] project_urls: Dict[str, str] # Metadata 2.0 # PEP 426 attempted to completely revamp the metadata format # but got stuck without ever being able to build consensus on # it and ultimately ended up withdrawn. # # However, a number of tools had started emiting METADATA with # `2.0` Metadata-Version, so for historical reasons, this version # was skipped. # Metadata 2.1 - PEP 566 description_content_type: str provides_extra: List[str] # Metadata 2.2 - PEP 643 dynamic: List[str] # Metadata 2.3 - PEP 685 # No new fields were added in PEP 685, just some edge case were # tightened up to provide better interoptability. _STRING_FIELDS = { "author", "author_email", "description", "description_content_type", "download_url", "home_page", "license", "maintainer", "maintainer_email", "metadata_version", "name", "requires_python", "summary", "version", } _LIST_STRING_FIELDS = { "classifiers", "dynamic", "obsoletes", "obsoletes_dist", "platforms", "provides", "provides_dist", "provides_extra", "requires", "requires_dist", "requires_external", "supported_platforms", } def _parse_keywords(data: str) -> List[str]: """Split a string of comma-separate keyboards into a list of keywords.""" return [k.strip() for k in data.split(",")] def _parse_project_urls(data: List[str]) -> Dict[str, str]: """Parse a list of label/URL string pairings separated by a comma.""" urls = {} for pair in data: # Our logic is slightly tricky here as we want to try and do # *something* reasonable with malformed data. # # The main thing that we have to worry about, is data that does # not have a ',' at all to split the label from the Value. There # isn't a singular right answer here, and we will fail validation # later on (if the caller is validating) so it doesn't *really* # matter, but since the missing value has to be an empty str # and our return value is dict[str, str], if we let the key # be the missing value, then they'd have multiple '' values that # overwrite each other in a accumulating dict. # # The other potentional issue is that it's possible to have the # same label multiple times in the metadata, with no solid "right" # answer with what to do in that case. As such, we'll do the only # thing we can, which is treat the field as unparseable and add it # to our list of unparsed fields. parts = [p.strip() for p in pair.split(",", 1)] parts.extend([""] * (max(0, 2 - len(parts)))) # Ensure 2 items # TODO: The spec doesn't say anything about if the keys should be # considered case sensitive or not... logically they should # be case-preserving and case-insensitive, but doing that # would open up more cases where we might have duplicate # entries. label, url = parts if label in urls: # The label already exists in our set of urls, so this field # is unparseable, and we can just add the whole thing to our # unparseable data and stop processing it. raise KeyError("duplicate labels in project urls") urls[label] = url return urls def _get_payload(msg: email.message.Message, source: Union[bytes, str]) -> str: """Get the body of the message.""" # If our source is a str, then our caller has managed encodings for us, # and we don't need to deal with it. if isinstance(source, str): payload: str = msg.get_payload() return payload # If our source is a bytes, then we're managing the encoding and we need # to deal with it. else: bpayload: bytes = msg.get_payload(decode=True) try: return bpayload.decode("utf8", "strict") except UnicodeDecodeError: raise ValueError("payload in an invalid encoding") # The various parse_FORMAT functions here are intended to be as lenient as # possible in their parsing, while still returning a correctly typed # RawMetadata. # # To aid in this, we also generally want to do as little touching of the # data as possible, except where there are possibly some historic holdovers # that make valid data awkward to work with. # # While this is a lower level, intermediate format than our ``Metadata`` # class, some light touch ups can make a massive difference in usability. # Map METADATA fields to RawMetadata. _EMAIL_TO_RAW_MAPPING = { "author": "author", "author-email": "author_email", "classifier": "classifiers", "description": "description", "description-content-type": "description_content_type", "download-url": "download_url", "dynamic": "dynamic", "home-page": "home_page", "keywords": "keywords", "license": "license", "maintainer": "maintainer", "maintainer-email": "maintainer_email", "metadata-version": "metadata_version", "name": "name", "obsoletes": "obsoletes", "obsoletes-dist": "obsoletes_dist", "platform": "platforms", "project-url": "project_urls", "provides": "provides", "provides-dist": "provides_dist", "provides-extra": "provides_extra", "requires": "requires", "requires-dist": "requires_dist", "requires-external": "requires_external", "requires-python": "requires_python", "summary": "summary", "supported-platform": "supported_platforms", "version": "version", } def parse_email(data: Union[bytes, str]) -> Tuple[RawMetadata, Dict[str, List[str]]]: """Parse a distribution's metadata. This function returns a two-item tuple of dicts. The first dict is of recognized fields from the core metadata specification. Fields that can be parsed and translated into Python's built-in types are converted appropriately. All other fields are left as-is. Fields that are allowed to appear multiple times are stored as lists. The second dict contains all other fields from the metadata. This includes any unrecognized fields. It also includes any fields which are expected to be parsed into a built-in type but were not formatted appropriately. Finally, any fields that are expected to appear only once but are repeated are included in this dict. """ raw: Dict[str, Union[str, List[str], Dict[str, str]]] = {} unparsed: Dict[str, List[str]] = {} if isinstance(data, str): parsed = email.parser.Parser(policy=email.policy.compat32).parsestr(data) else: parsed = email.parser.BytesParser(policy=email.policy.compat32).parsebytes(data) # We have to wrap parsed.keys() in a set, because in the case of multiple # values for a key (a list), the key will appear multiple times in the # list of keys, but we're avoiding that by using get_all(). for name in frozenset(parsed.keys()): # Header names in RFC are case insensitive, so we'll normalize to all # lower case to make comparisons easier. name = name.lower() # We use get_all() here, even for fields that aren't multiple use, # because otherwise someone could have e.g. two Name fields, and we # would just silently ignore it rather than doing something about it. headers = parsed.get_all(name) # The way the email module works when parsing bytes is that it # unconditionally decodes the bytes as ascii using the surrogateescape # handler. When you pull that data back out (such as with get_all() ), # it looks to see if the str has any surrogate escapes, and if it does # it wraps it in a Header object instead of returning the string. # # As such, we'll look for those Header objects, and fix up the encoding. value = [] # Flag if we have run into any issues processing the headers, thus # signalling that the data belongs in 'unparsed'. valid_encoding = True for h in headers: # It's unclear if this can return more types than just a Header or # a str, so we'll just assert here to make sure. assert isinstance(h, (email.header.Header, str)) # If it's a header object, we need to do our little dance to get # the real data out of it. In cases where there is invalid data # we're going to end up with mojibake, but there's no obvious, good # way around that without reimplementing parts of the Header object # ourselves. # # That should be fine since, if mojibacked happens, this key is # going into the unparsed dict anyways. if isinstance(h, email.header.Header): # The Header object stores it's data as chunks, and each chunk # can be independently encoded, so we'll need to check each # of them. chunks: List[Tuple[bytes, Optional[str]]] = [] for bin, encoding in email.header.decode_header(h): try: bin.decode("utf8", "strict") except UnicodeDecodeError: # Enable mojibake. encoding = "latin1" valid_encoding = False else: encoding = "utf8" chunks.append((bin, encoding)) # Turn our chunks back into a Header object, then let that # Header object do the right thing to turn them into a # string for us. value.append(str(email.header.make_header(chunks))) # This is already a string, so just add it. else: value.append(h) # We've processed all of our values to get them into a list of str, # but we may have mojibake data, in which case this is an unparsed # field. if not valid_encoding: unparsed[name] = value continue raw_name = _EMAIL_TO_RAW_MAPPING.get(name) if raw_name is None: # This is a bit of a weird situation, we've encountered a key that # we don't know what it means, so we don't know whether it's meant # to be a list or not. # # Since we can't really tell one way or another, we'll just leave it # as a list, even though it may be a single item list, because that's # what makes the most sense for email headers. unparsed[name] = value continue # If this is one of our string fields, then we'll check to see if our # value is a list of a single item. If it is then we'll assume that # it was emitted as a single string, and unwrap the str from inside # the list. # # If it's any other kind of data, then we haven't the faintest clue # what we should parse it as, and we have to just add it to our list # of unparsed stuff. if raw_name in _STRING_FIELDS and len(value) == 1: raw[raw_name] = value[0] # If this is one of our list of string fields, then we can just assign # the value, since email *only* has strings, and our get_all() call # above ensures that this is a list. elif raw_name in _LIST_STRING_FIELDS: raw[raw_name] = value # Special Case: Keywords # The keywords field is implemented in the metadata spec as a str, # but it conceptually is a list of strings, and is serialized using # ", ".join(keywords), so we'll do some light data massaging to turn # this into what it logically is. elif raw_name == "keywords" and len(value) == 1: raw[raw_name] = _parse_keywords(value[0]) # Special Case: Project-URL # The project urls is implemented in the metadata spec as a list of # specially-formatted strings that represent a key and a value, which # is fundamentally a mapping, however the email format doesn't support # mappings in a sane way, so it was crammed into a list of strings # instead. # # We will do a little light data massaging to turn this into a map as # it logically should be. elif raw_name == "project_urls": try: raw[raw_name] = _parse_project_urls(value) except KeyError: unparsed[name] = value # Nothing that we've done has managed to parse this, so it'll just # throw it in our unparseable data and move on. else: unparsed[name] = value # We need to support getting the Description from the message payload in # addition to getting it from the the headers. This does mean, though, there # is the possibility of it being set both ways, in which case we put both # in 'unparsed' since we don't know which is right. try: payload = _get_payload(parsed, data) except ValueError: unparsed.setdefault("description", []).append( parsed.get_payload(decode=isinstance(data, bytes)) ) else: if payload: # Check to see if we've already got a description, if so then both # it, and this body move to unparseable. if "description" in raw: description_header = cast(str, raw.pop("description")) unparsed.setdefault("description", []).extend( [description_header, payload] ) elif "description" in unparsed: unparsed["description"].append(payload) else: raw["description"] = payload # We need to cast our `raw` to a metadata, because a TypedDict only support # literal key names, but we're computing our key names on purpose, but the # way this function is implemented, our `TypedDict` can only have valid key # names. return cast(RawMetadata, raw), unparsed ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/requirements.py0000644000175100001730000000632714467657412025012 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import urllib.parse from typing import Any, List, Optional, Set from ._parser import parse_requirement as _parse_requirement from ._tokenizer import ParserSyntaxError from .markers import Marker, _normalize_extra_values from .specifiers import SpecifierSet class InvalidRequirement(ValueError): """ An invalid requirement was found, users should refer to PEP 508. """ class Requirement: """Parse a requirement. Parse a given requirement string into its parts, such as name, specifier, URL, and extras. Raises InvalidRequirement on a badly-formed requirement string. """ # TODO: Can we test whether something is contained within a requirement? # If so how do we do that? Do we need to test against the _name_ of # the thing as well as the version? What about the markers? # TODO: Can we normalize the name and extra name? def __init__(self, requirement_string: str) -> None: try: parsed = _parse_requirement(requirement_string) except ParserSyntaxError as e: raise InvalidRequirement(str(e)) from e self.name: str = parsed.name if parsed.url: parsed_url = urllib.parse.urlparse(parsed.url) if parsed_url.scheme == "file": if urllib.parse.urlunparse(parsed_url) != parsed.url: raise InvalidRequirement("Invalid URL given") elif not (parsed_url.scheme and parsed_url.netloc) or ( not parsed_url.scheme and not parsed_url.netloc ): raise InvalidRequirement(f"Invalid URL: {parsed.url}") self.url: Optional[str] = parsed.url else: self.url = None self.extras: Set[str] = set(parsed.extras if parsed.extras else []) self.specifier: SpecifierSet = SpecifierSet(parsed.specifier) self.marker: Optional[Marker] = None if parsed.marker is not None: self.marker = Marker.__new__(Marker) self.marker._markers = _normalize_extra_values(parsed.marker) def __str__(self) -> str: parts: List[str] = [self.name] if self.extras: formatted_extras = ",".join(sorted(self.extras)) parts.append(f"[{formatted_extras}]") if self.specifier: parts.append(str(self.specifier)) if self.url: parts.append(f"@ {self.url}") if self.marker: parts.append(" ") if self.marker: parts.append(f"; {self.marker}") return "".join(parts) def __repr__(self) -> str: return f"" def __hash__(self) -> int: return hash((self.__class__.__name__, str(self))) def __eq__(self, other: Any) -> bool: if not isinstance(other, Requirement): return NotImplemented return ( self.name == other.name and self.extras == other.extras and self.specifier == other.specifier and self.url == other.url and self.marker == other.marker ) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/specifiers.py0000644000175100001730000011444614467657412024425 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. """ .. testsetup:: from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier from packaging.version import Version """ import abc import itertools import re from typing import ( Callable, Iterable, Iterator, List, Optional, Set, Tuple, TypeVar, Union, ) from .utils import canonicalize_version from .version import Version UnparsedVersion = Union[Version, str] UnparsedVersionVar = TypeVar("UnparsedVersionVar", bound=UnparsedVersion) CallableOperator = Callable[[Version, str], bool] def _coerce_version(version: UnparsedVersion) -> Version: if not isinstance(version, Version): version = Version(version) return version class InvalidSpecifier(ValueError): """ Raised when attempting to create a :class:`Specifier` with a specifier string that is invalid. >>> Specifier("lolwat") Traceback (most recent call last): ... packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat' """ class BaseSpecifier(metaclass=abc.ABCMeta): @abc.abstractmethod def __str__(self) -> str: """ Returns the str representation of this Specifier-like object. This should be representative of the Specifier itself. """ @abc.abstractmethod def __hash__(self) -> int: """ Returns a hash value for this Specifier-like object. """ @abc.abstractmethod def __eq__(self, other: object) -> bool: """ Returns a boolean representing whether or not the two Specifier-like objects are equal. :param other: The other object to check against. """ @property @abc.abstractmethod def prereleases(self) -> Optional[bool]: """Whether or not pre-releases as a whole are allowed. This can be set to either ``True`` or ``False`` to explicitly enable or disable prereleases or it can be set to ``None`` (the default) to use default semantics. """ @prereleases.setter def prereleases(self, value: bool) -> None: """Setter for :attr:`prereleases`. :param value: The value to set. """ @abc.abstractmethod def contains(self, item: str, prereleases: Optional[bool] = None) -> bool: """ Determines if the given item is contained within this specifier. """ @abc.abstractmethod def filter( self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None ) -> Iterator[UnparsedVersionVar]: """ Takes an iterable of items and filters them so that only items which are contained within this specifier are allowed in it. """ class Specifier(BaseSpecifier): """This class abstracts handling of version specifiers. .. tip:: It is generally not required to instantiate this manually. You should instead prefer to work with :class:`SpecifierSet` instead, which can parse comma-separated version specifiers (which is what package metadata contains). """ _operator_regex_str = r""" (?P(~=|==|!=|<=|>=|<|>|===)) """ _version_regex_str = r""" (?P (?: # The identity operators allow for an escape hatch that will # do an exact string match of the version you wish to install. # This will not be parsed by PEP 440 and we cannot determine # any semantic meaning from it. This operator is discouraged # but included entirely as an escape hatch. (?<====) # Only match for the identity operator \s* [^\s;)]* # The arbitrary version can be just about anything, # we match everything except for whitespace, a # semi-colon for marker support, and a closing paren # since versions can be enclosed in them. ) | (?: # The (non)equality operators allow for wild card and local # versions to be specified so we have to define these two # operators separately to enable that. (?<===|!=) # Only match for equals and not equals \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)* # release # You cannot use a wild card and a pre-release, post-release, a dev or # local version together so group them with a | and make them optional. (?: \.\* # Wild card syntax of .* | (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local )? ) | (?: # The compatible operator requires at least two digits in the # release segment. (?<=~=) # Only match for the compatible operator \s* v? (?:[0-9]+!)? # epoch [0-9]+(?:\.[0-9]+)+ # release (We have a + instead of a *) (?: # pre release [-_\.]? (alpha|beta|preview|pre|a|b|c|rc) [-_\.]? [0-9]* )? (?: # post release (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*) )? (?:[-_\.]?dev[-_\.]?[0-9]*)? # dev release ) | (?: # All other operators only allow a sub set of what the # (non)equality operators do. Specifically they do not allow # local versions to be specified nor do they allow the prefix # matching wild cards. (?=": "greater_than_equal", "<": "less_than", ">": "greater_than", "===": "arbitrary", } def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None: """Initialize a Specifier instance. :param spec: The string representation of a specifier which will be parsed and normalized before use. :param prereleases: This tells the specifier if it should accept prerelease versions if applicable or not. The default of ``None`` will autodetect it from the given specifiers. :raises InvalidSpecifier: If the given specifier is invalid (i.e. bad syntax). """ match = self._regex.search(spec) if not match: raise InvalidSpecifier(f"Invalid specifier: '{spec}'") self._spec: Tuple[str, str] = ( match.group("operator").strip(), match.group("version").strip(), ) # Store whether or not this Specifier should accept prereleases self._prereleases = prereleases # https://github.com/python/mypy/pull/13475#pullrequestreview-1079784515 @property # type: ignore[override] def prereleases(self) -> bool: # If there is an explicit prereleases set for this, then we'll just # blindly use that. if self._prereleases is not None: return self._prereleases # Look at all of our specifiers and determine if they are inclusive # operators, and if they are if they are including an explicit # prerelease. operator, version = self._spec if operator in ["==", ">=", "<=", "~=", "==="]: # The == specifier can include a trailing .*, if it does we # want to remove before parsing. if operator == "==" and version.endswith(".*"): version = version[:-2] # Parse the version, and if it is a pre-release than this # specifier allows pre-releases. if Version(version).is_prerelease: return True return False @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value @property def operator(self) -> str: """The operator of this specifier. >>> Specifier("==1.2.3").operator '==' """ return self._spec[0] @property def version(self) -> str: """The version of this specifier. >>> Specifier("==1.2.3").version '1.2.3' """ return self._spec[1] def __repr__(self) -> str: """A representation of the Specifier that shows all internal state. >>> Specifier('>=1.0.0') =1.0.0')> >>> Specifier('>=1.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> Specifier('>=1.0.0', prereleases=True) =1.0.0', prereleases=True)> """ pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return f"<{self.__class__.__name__}({str(self)!r}{pre})>" def __str__(self) -> str: """A string representation of the Specifier that can be round-tripped. >>> str(Specifier('>=1.0.0')) '>=1.0.0' >>> str(Specifier('>=1.0.0', prereleases=False)) '>=1.0.0' """ return "{}{}".format(*self._spec) @property def _canonical_spec(self) -> Tuple[str, str]: canonical_version = canonicalize_version( self._spec[1], strip_trailing_zero=(self._spec[0] != "~="), ) return self._spec[0], canonical_version def __hash__(self) -> int: return hash(self._canonical_spec) def __eq__(self, other: object) -> bool: """Whether or not the two Specifier-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0") True >>> (Specifier("==1.2.3", prereleases=False) == ... Specifier("==1.2.3", prereleases=True)) True >>> Specifier("==1.2.3") == "==1.2.3" True >>> Specifier("==1.2.3") == Specifier("==1.2.4") False >>> Specifier("==1.2.3") == Specifier("~=1.2.3") False """ if isinstance(other, str): try: other = self.__class__(str(other)) except InvalidSpecifier: return NotImplemented elif not isinstance(other, self.__class__): return NotImplemented return self._canonical_spec == other._canonical_spec def _get_operator(self, op: str) -> CallableOperator: operator_callable: CallableOperator = getattr( self, f"_compare_{self._operators[op]}" ) return operator_callable def _compare_compatible(self, prospective: Version, spec: str) -> bool: # Compatible releases have an equivalent combination of >= and ==. That # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to # implement this in terms of the other specifiers instead of # implementing it ourselves. The only thing we need to do is construct # the other specifiers. # We want everything but the last item in the version, but we want to # ignore suffix segments. prefix = ".".join( list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1] ) # Add the prefix notation to the end of our string prefix += ".*" return self._get_operator(">=")(prospective, spec) and self._get_operator("==")( prospective, prefix ) def _compare_equal(self, prospective: Version, spec: str) -> bool: # We need special logic to handle prefix matching if spec.endswith(".*"): # In the case of prefix matching we want to ignore local segment. normalized_prospective = canonicalize_version( prospective.public, strip_trailing_zero=False ) # Get the normalized version string ignoring the trailing .* normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False) # Split the spec out by dots, and pretend that there is an implicit # dot in between a release segment and a pre-release segment. split_spec = _version_split(normalized_spec) # Split the prospective version out by dots, and pretend that there # is an implicit dot in between a release segment and a pre-release # segment. split_prospective = _version_split(normalized_prospective) # 0-pad the prospective version before shortening it to get the correct # shortened version. padded_prospective, _ = _pad_version(split_prospective, split_spec) # Shorten the prospective version to be the same length as the spec # so that we can determine if the specifier is a prefix of the # prospective version or not. shortened_prospective = padded_prospective[: len(split_spec)] return shortened_prospective == split_spec else: # Convert our spec string into a Version spec_version = Version(spec) # If the specifier does not have a local segment, then we want to # act as if the prospective version also does not have a local # segment. if not spec_version.local: prospective = Version(prospective.public) return prospective == spec_version def _compare_not_equal(self, prospective: Version, spec: str) -> bool: return not self._compare_equal(prospective, spec) def _compare_less_than_equal(self, prospective: Version, spec: str) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) <= Version(spec) def _compare_greater_than_equal(self, prospective: Version, spec: str) -> bool: # NB: Local version identifiers are NOT permitted in the version # specifier, so local version labels can be universally removed from # the prospective version. return Version(prospective.public) >= Version(spec) def _compare_less_than(self, prospective: Version, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is less than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective < spec: return False # This special case is here so that, unless the specifier itself # includes is a pre-release version, that we do not accept pre-release # versions for the version mentioned in the specifier (e.g. <3.1 should # not match 3.1.dev0, but should match 3.0.dev0). if not spec.is_prerelease and prospective.is_prerelease: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # less than the spec version *and* it's not a pre-release of the same # version in the spec. return True def _compare_greater_than(self, prospective: Version, spec_str: str) -> bool: # Convert our spec to a Version instance, since we'll want to work with # it as a version. spec = Version(spec_str) # Check to see if the prospective version is greater than the spec # version. If it's not we can short circuit and just return False now # instead of doing extra unneeded work. if not prospective > spec: return False # This special case is here so that, unless the specifier itself # includes is a post-release version, that we do not accept # post-release versions for the version mentioned in the specifier # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0). if not spec.is_postrelease and prospective.is_postrelease: if Version(prospective.base_version) == Version(spec.base_version): return False # Ensure that we do not allow a local version of the version mentioned # in the specifier, which is technically greater than, to match. if prospective.local is not None: if Version(prospective.base_version) == Version(spec.base_version): return False # If we've gotten to here, it means that prospective version is both # greater than the spec version *and* it's not a pre-release of the # same version in the spec. return True def _compare_arbitrary(self, prospective: Version, spec: str) -> bool: return str(prospective).lower() == str(spec).lower() def __contains__(self, item: Union[str, Version]) -> bool: """Return whether or not the item is contained in this specifier. :param item: The item to check for. This is used for the ``in`` operator and behaves the same as :meth:`contains` with no ``prereleases`` argument passed. >>> "1.2.3" in Specifier(">=1.2.3") True >>> Version("1.2.3") in Specifier(">=1.2.3") True >>> "1.0.0" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3") False >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True) True """ return self.contains(item) def contains( self, item: UnparsedVersion, prereleases: Optional[bool] = None ) -> bool: """Return whether or not the item is contained in this specifier. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this Specifier. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> Specifier(">=1.2.3").contains("1.2.3") True >>> Specifier(">=1.2.3").contains(Version("1.2.3")) True >>> Specifier(">=1.2.3").contains("1.0.0") False >>> Specifier(">=1.2.3").contains("1.3.0a1") False >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1") True >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True) True """ # Determine if prereleases are to be allowed or not. if prereleases is None: prereleases = self.prereleases # Normalize item to a Version, this allows us to have a shortcut for # "2.0" in Specifier(">=2") normalized_item = _coerce_version(item) # Determine if we should be supporting prereleases in this specifier # or not, if we do not support prereleases than we can short circuit # logic if this version is a prereleases. if normalized_item.is_prerelease and not prereleases: return False # Actually do the comparison to determine if this item is contained # within this Specifier or not. operator_callable: CallableOperator = self._get_operator(self.operator) return operator_callable(normalized_item, self.version) def filter( self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None ) -> Iterator[UnparsedVersionVar]: """Filter items in the given iterable, that match the specifier. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(Specifier().contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")])) ['1.2.3', '1.3', ] >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"])) ['1.5a1'] >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] """ yielded = False found_prereleases = [] kw = {"prereleases": prereleases if prereleases is not None else True} # Attempt to iterate over all the values in the iterable and if any of # them match, yield them. for version in iterable: parsed_version = _coerce_version(version) if self.contains(parsed_version, **kw): # If our version is a prerelease, and we were not set to allow # prereleases, then we'll store it for later in case nothing # else matches this specifier. if parsed_version.is_prerelease and not ( prereleases or self.prereleases ): found_prereleases.append(version) # Either this is not a prerelease, or we should have been # accepting prereleases from the beginning. else: yielded = True yield version # Now that we've iterated over everything, determine if we've yielded # any values, and if we have not and we have any prereleases stored up # then we will go ahead and yield the prereleases. if not yielded and found_prereleases: for version in found_prereleases: yield version _prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$") def _version_split(version: str) -> List[str]: result: List[str] = [] for item in version.split("."): match = _prefix_regex.search(item) if match: result.extend(match.groups()) else: result.append(item) return result def _is_not_suffix(segment: str) -> bool: return not any( segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post") ) def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]: left_split, right_split = [], [] # Get the release segment of our versions left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left))) right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right))) # Get the rest of our versions left_split.append(left[len(left_split[0]) :]) right_split.append(right[len(right_split[0]) :]) # Insert our padding left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0]))) right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0]))) return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split))) class SpecifierSet(BaseSpecifier): """This class abstracts handling of a set of version specifiers. It can be passed a single specifier (``>=3.0``), a comma-separated list of specifiers (``>=3.0,!=3.1``), or no specifier at all. """ def __init__( self, specifiers: str = "", prereleases: Optional[bool] = None ) -> None: """Initialize a SpecifierSet instance. :param specifiers: The string representation of a specifier or a comma-separated list of specifiers which will be parsed and normalized before use. :param prereleases: This tells the SpecifierSet if it should accept prerelease versions if applicable or not. The default of ``None`` will autodetect it from the given specifiers. :raises InvalidSpecifier: If the given ``specifiers`` are not parseable than this exception will be raised. """ # Split on `,` to break each individual specifier into it's own item, and # strip each item to remove leading/trailing whitespace. split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()] # Parsed each individual specifier, attempting first to make it a # Specifier. parsed: Set[Specifier] = set() for specifier in split_specifiers: parsed.add(Specifier(specifier)) # Turn our parsed specifiers into a frozen set and save them for later. self._specs = frozenset(parsed) # Store our prereleases value so we can use it later to determine if # we accept prereleases or not. self._prereleases = prereleases @property def prereleases(self) -> Optional[bool]: # If we have been given an explicit prerelease modifier, then we'll # pass that through here. if self._prereleases is not None: return self._prereleases # If we don't have any specifiers, and we don't have a forced value, # then we'll just return None since we don't know if this should have # pre-releases or not. if not self._specs: return None # Otherwise we'll see if any of the given specifiers accept # prereleases, if any of them do we'll return True, otherwise False. return any(s.prereleases for s in self._specs) @prereleases.setter def prereleases(self, value: bool) -> None: self._prereleases = value def __repr__(self) -> str: """A representation of the specifier set that shows all internal state. Note that the ordering of the individual specifiers within the set may not match the input string. >>> SpecifierSet('>=1.0.0,!=2.0.0') =1.0.0')> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False) =1.0.0', prereleases=False)> >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True) =1.0.0', prereleases=True)> """ pre = ( f", prereleases={self.prereleases!r}" if self._prereleases is not None else "" ) return f"" def __str__(self) -> str: """A string representation of the specifier set that can be round-tripped. Note that the ordering of the individual specifiers within the set may not match the input string. >>> str(SpecifierSet(">=1.0.0,!=1.0.1")) '!=1.0.1,>=1.0.0' >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False)) '!=1.0.1,>=1.0.0' """ return ",".join(sorted(str(s) for s in self._specs)) def __hash__(self) -> int: return hash(self._specs) def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet": """Return a SpecifierSet which is a combination of the two sets. :param other: The other object to combine with. >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1' =1.0.0')> >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1') =1.0.0')> """ if isinstance(other, str): other = SpecifierSet(other) elif not isinstance(other, SpecifierSet): return NotImplemented specifier = SpecifierSet() specifier._specs = frozenset(self._specs | other._specs) if self._prereleases is None and other._prereleases is not None: specifier._prereleases = other._prereleases elif self._prereleases is not None and other._prereleases is None: specifier._prereleases = self._prereleases elif self._prereleases == other._prereleases: specifier._prereleases = self._prereleases else: raise ValueError( "Cannot combine SpecifierSets with True and False prerelease " "overrides." ) return specifier def __eq__(self, other: object) -> bool: """Whether or not the two SpecifierSet-like objects are equal. :param other: The other object to check against. The value of :attr:`prereleases` is ignored. >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1") True >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) == ... SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)) True >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1" True >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0") False >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2") False """ if isinstance(other, (str, Specifier)): other = SpecifierSet(str(other)) elif not isinstance(other, SpecifierSet): return NotImplemented return self._specs == other._specs def __len__(self) -> int: """Returns the number of specifiers in this specifier set.""" return len(self._specs) def __iter__(self) -> Iterator[Specifier]: """ Returns an iterator over all the underlying :class:`Specifier` instances in this specifier set. >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str) [, =1.0.0')>] """ return iter(self._specs) def __contains__(self, item: UnparsedVersion) -> bool: """Return whether or not the item is contained in this specifier. :param item: The item to check for. This is used for the ``in`` operator and behaves the same as :meth:`contains` with no ``prereleases`` argument passed. >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1") True >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1") True >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1") False >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True) True """ return self.contains(item) def contains( self, item: UnparsedVersion, prereleases: Optional[bool] = None, installed: Optional[bool] = None, ) -> bool: """Return whether or not the item is contained in this SpecifierSet. :param item: The item to check for, which can be a version string or a :class:`Version` instance. :param prereleases: Whether or not to match prereleases with this SpecifierSet. If set to ``None`` (the default), it uses :attr:`prereleases` to determine whether or not prereleases are allowed. >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3")) True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1") False >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1") False >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1") True >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True) True """ # Ensure that our item is a Version instance. if not isinstance(item, Version): item = Version(item) # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # We can determine if we're going to allow pre-releases by looking to # see if any of the underlying items supports them. If none of them do # and this item is a pre-release then we do not allow it and we can # short circuit that here. # Note: This means that 1.0.dev1 would not be contained in something # like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0 if not prereleases and item.is_prerelease: return False if installed and item.is_prerelease: item = Version(item.base_version) # We simply dispatch to the underlying specs here to make sure that the # given version is contained within all of them. # Note: This use of all() here means that an empty set of specifiers # will always return True, this is an explicit design decision. return all(s.contains(item, prereleases=prereleases) for s in self._specs) def filter( self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None ) -> Iterator[UnparsedVersionVar]: """Filter items in the given iterable, that match the specifiers in this set. :param iterable: An iterable that can contain version strings and :class:`Version` instances. The items in the iterable will be filtered according to the specifier. :param prereleases: Whether or not to allow prereleases in the returned iterator. If set to ``None`` (the default), it will be intelligently decide whether to allow prereleases or not (based on the :attr:`prereleases` attribute, and whether the only versions matching are prereleases). This method is smarter than just ``filter(SpecifierSet(...).contains, [...])`` because it implements the rule from :pep:`440` that a prerelease item SHOULD be accepted if no other versions match the given specifier. >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")])) ['1.3', ] >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"])) [] >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] An "empty" SpecifierSet will filter items based on the presence of prerelease versions in the set. >>> list(SpecifierSet("").filter(["1.3", "1.5a1"])) ['1.3'] >>> list(SpecifierSet("").filter(["1.5a1"])) ['1.5a1'] >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"])) ['1.3', '1.5a1'] >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True)) ['1.3', '1.5a1'] """ # Determine if we're forcing a prerelease or not, if we're not forcing # one for this particular filter call, then we'll use whatever the # SpecifierSet thinks for whether or not we should support prereleases. if prereleases is None: prereleases = self.prereleases # If we have any specifiers, then we want to wrap our iterable in the # filter method for each one, this will act as a logical AND amongst # each specifier. if self._specs: for spec in self._specs: iterable = spec.filter(iterable, prereleases=bool(prereleases)) return iter(iterable) # If we do not have any specifiers, then we need to have a rough filter # which will filter out any pre-releases, unless there are no final # releases. else: filtered: List[UnparsedVersionVar] = [] found_prereleases: List[UnparsedVersionVar] = [] for item in iterable: parsed_version = _coerce_version(item) # Store any item which is a pre-release for later unless we've # already found a final version or we are accepting prereleases if parsed_version.is_prerelease and not prereleases: if not filtered: found_prereleases.append(item) else: filtered.append(item) # If we've found no items except for pre-releases, then we'll go # ahead and use the pre-releases if not filtered and found_prereleases and prereleases is None: return iter(found_prereleases) return iter(filtered) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/tags.py0000644000175100001730000004327214467657412023225 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import logging import platform import subprocess import sys import sysconfig from importlib.machinery import EXTENSION_SUFFIXES from typing import ( Dict, FrozenSet, Iterable, Iterator, List, Optional, Sequence, Tuple, Union, cast, ) from . import _manylinux, _musllinux logger = logging.getLogger(__name__) PythonVersion = Sequence[int] MacVersion = Tuple[int, int] INTERPRETER_SHORT_NAMES: Dict[str, str] = { "python": "py", # Generic. "cpython": "cp", "pypy": "pp", "ironpython": "ip", "jython": "jy", } _32_BIT_INTERPRETER = sys.maxsize <= 2**32 class Tag: """ A representation of the tag triple for a wheel. Instances are considered immutable and thus are hashable. Equality checking is also supported. """ __slots__ = ["_interpreter", "_abi", "_platform", "_hash"] def __init__(self, interpreter: str, abi: str, platform: str) -> None: self._interpreter = interpreter.lower() self._abi = abi.lower() self._platform = platform.lower() # The __hash__ of every single element in a Set[Tag] will be evaluated each time # that a set calls its `.disjoint()` method, which may be called hundreds of # times when scanning a page of links for packages with tags matching that # Set[Tag]. Pre-computing the value here produces significant speedups for # downstream consumers. self._hash = hash((self._interpreter, self._abi, self._platform)) @property def interpreter(self) -> str: return self._interpreter @property def abi(self) -> str: return self._abi @property def platform(self) -> str: return self._platform def __eq__(self, other: object) -> bool: if not isinstance(other, Tag): return NotImplemented return ( (self._hash == other._hash) # Short-circuit ASAP for perf reasons. and (self._platform == other._platform) and (self._abi == other._abi) and (self._interpreter == other._interpreter) ) def __hash__(self) -> int: return self._hash def __str__(self) -> str: return f"{self._interpreter}-{self._abi}-{self._platform}" def __repr__(self) -> str: return f"<{self} @ {id(self)}>" def parse_tag(tag: str) -> FrozenSet[Tag]: """ Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances. Returning a set is required due to the possibility that the tag is a compressed tag set. """ tags = set() interpreters, abis, platforms = tag.split("-") for interpreter in interpreters.split("."): for abi in abis.split("."): for platform_ in platforms.split("."): tags.add(Tag(interpreter, abi, platform_)) return frozenset(tags) def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]: value: Union[int, str, None] = sysconfig.get_config_var(name) if value is None and warn: logger.debug( "Config variable '%s' is unset, Python ABI tag may be incorrect", name ) return value def _normalize_string(string: str) -> str: return string.replace(".", "_").replace("-", "_").replace(" ", "_") def _abi3_applies(python_version: PythonVersion) -> bool: """ Determine if the Python version supports abi3. PEP 384 was first implemented in Python 3.2. """ return len(python_version) > 1 and tuple(python_version) >= (3, 2) def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]: py_version = tuple(py_version) # To allow for version comparison. abis = [] version = _version_nodot(py_version[:2]) debug = pymalloc = ucs4 = "" with_debug = _get_config_var("Py_DEBUG", warn) has_refcount = hasattr(sys, "gettotalrefcount") # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled # extension modules is the best option. # https://github.com/pypa/pip/issues/3383#issuecomment-173267692 has_ext = "_d.pyd" in EXTENSION_SUFFIXES if with_debug or (with_debug is None and (has_refcount or has_ext)): debug = "d" if py_version < (3, 8): with_pymalloc = _get_config_var("WITH_PYMALLOC", warn) if with_pymalloc or with_pymalloc is None: pymalloc = "m" if py_version < (3, 3): unicode_size = _get_config_var("Py_UNICODE_SIZE", warn) if unicode_size == 4 or ( unicode_size is None and sys.maxunicode == 0x10FFFF ): ucs4 = "u" elif debug: # Debug builds can also load "normal" extension modules. # We can also assume no UCS-4 or pymalloc requirement. abis.append(f"cp{version}") abis.insert( 0, "cp{version}{debug}{pymalloc}{ucs4}".format( version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4 ), ) return abis def cpython_tags( python_version: Optional[PythonVersion] = None, abis: Optional[Iterable[str]] = None, platforms: Optional[Iterable[str]] = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a CPython interpreter. The tags consist of: - cp-- - cp-abi3- - cp-none- - cp-abi3- # Older Python versions down to 3.2. If python_version only specifies a major version then user-provided ABIs and the 'none' ABItag will be used. If 'abi3' or 'none' are specified in 'abis' then they will be yielded at their normal position and not at the beginning. """ if not python_version: python_version = sys.version_info[:2] interpreter = f"cp{_version_nodot(python_version[:2])}" if abis is None: if len(python_version) > 1: abis = _cpython_abis(python_version, warn) else: abis = [] abis = list(abis) # 'abi3' and 'none' are explicitly handled later. for explicit_abi in ("abi3", "none"): try: abis.remove(explicit_abi) except ValueError: pass platforms = list(platforms or platform_tags()) for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) if _abi3_applies(python_version): yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms) yield from (Tag(interpreter, "none", platform_) for platform_ in platforms) if _abi3_applies(python_version): for minor_version in range(python_version[1] - 1, 1, -1): for platform_ in platforms: interpreter = "cp{version}".format( version=_version_nodot((python_version[0], minor_version)) ) yield Tag(interpreter, "abi3", platform_) def _generic_abi() -> List[str]: """ Return the ABI tag based on EXT_SUFFIX. """ # The following are examples of `EXT_SUFFIX`. # We want to keep the parts which are related to the ABI and remove the # parts which are related to the platform: # - linux: '.cpython-310-x86_64-linux-gnu.so' => cp310 # - mac: '.cpython-310-darwin.so' => cp310 # - win: '.cp310-win_amd64.pyd' => cp310 # - win: '.pyd' => cp37 (uses _cpython_abis()) # - pypy: '.pypy38-pp73-x86_64-linux-gnu.so' => pypy38_pp73 # - graalpy: '.graalpy-38-native-x86_64-darwin.dylib' # => graalpy_38_native ext_suffix = _get_config_var("EXT_SUFFIX", warn=True) if not isinstance(ext_suffix, str) or ext_suffix[0] != ".": raise SystemError("invalid sysconfig.get_config_var('EXT_SUFFIX')") parts = ext_suffix.split(".") if len(parts) < 3: # CPython3.7 and earlier uses ".pyd" on Windows. return _cpython_abis(sys.version_info[:2]) soabi = parts[1] if soabi.startswith("cpython"): # non-windows abi = "cp" + soabi.split("-")[1] elif soabi.startswith("cp"): # windows abi = soabi.split("-")[0] elif soabi.startswith("pypy"): abi = "-".join(soabi.split("-")[:2]) elif soabi.startswith("graalpy"): abi = "-".join(soabi.split("-")[:3]) elif soabi: # pyston, ironpython, others? abi = soabi else: return [] return [_normalize_string(abi)] def generic_tags( interpreter: Optional[str] = None, abis: Optional[Iterable[str]] = None, platforms: Optional[Iterable[str]] = None, *, warn: bool = False, ) -> Iterator[Tag]: """ Yields the tags for a generic interpreter. The tags consist of: - -- The "none" ABI will be added if it was not explicitly provided. """ if not interpreter: interp_name = interpreter_name() interp_version = interpreter_version(warn=warn) interpreter = "".join([interp_name, interp_version]) if abis is None: abis = _generic_abi() else: abis = list(abis) platforms = list(platforms or platform_tags()) if "none" not in abis: abis.append("none") for abi in abis: for platform_ in platforms: yield Tag(interpreter, abi, platform_) def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]: """ Yields Python versions in descending order. After the latest version, the major-only version will be yielded, and then all previous versions of that major version. """ if len(py_version) > 1: yield f"py{_version_nodot(py_version[:2])}" yield f"py{py_version[0]}" if len(py_version) > 1: for minor in range(py_version[1] - 1, -1, -1): yield f"py{_version_nodot((py_version[0], minor))}" def compatible_tags( python_version: Optional[PythonVersion] = None, interpreter: Optional[str] = None, platforms: Optional[Iterable[str]] = None, ) -> Iterator[Tag]: """ Yields the sequence of tags that are compatible with a specific version of Python. The tags consist of: - py*-none- - -none-any # ... if `interpreter` is provided. - py*-none-any """ if not python_version: python_version = sys.version_info[:2] platforms = list(platforms or platform_tags()) for version in _py_interpreter_range(python_version): for platform_ in platforms: yield Tag(version, "none", platform_) if interpreter: yield Tag(interpreter, "none", "any") for version in _py_interpreter_range(python_version): yield Tag(version, "none", "any") def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str: if not is_32bit: return arch if arch.startswith("ppc"): return "ppc" return "i386" def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]: formats = [cpu_arch] if cpu_arch == "x86_64": if version < (10, 4): return [] formats.extend(["intel", "fat64", "fat32"]) elif cpu_arch == "i386": if version < (10, 4): return [] formats.extend(["intel", "fat32", "fat"]) elif cpu_arch == "ppc64": # TODO: Need to care about 32-bit PPC for ppc64 through 10.2? if version > (10, 5) or version < (10, 4): return [] formats.append("fat64") elif cpu_arch == "ppc": if version > (10, 6): return [] formats.extend(["fat32", "fat"]) if cpu_arch in {"arm64", "x86_64"}: formats.append("universal2") if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}: formats.append("universal") return formats def mac_platforms( version: Optional[MacVersion] = None, arch: Optional[str] = None ) -> Iterator[str]: """ Yields the platform tags for a macOS system. The `version` parameter is a two-item tuple specifying the macOS version to generate platform tags for. The `arch` parameter is the CPU architecture to generate platform tags for. Both parameters default to the appropriate value for the current system. """ version_str, _, cpu_arch = platform.mac_ver() if version is None: version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2]))) if version == (10, 16): # When built against an older macOS SDK, Python will report macOS 10.16 # instead of the real version. version_str = subprocess.run( [ sys.executable, "-sS", "-c", "import platform; print(platform.mac_ver()[0])", ], check=True, env={"SYSTEM_VERSION_COMPAT": "0"}, stdout=subprocess.PIPE, universal_newlines=True, ).stdout version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2]))) else: version = version if arch is None: arch = _mac_arch(cpu_arch) else: arch = arch if (10, 0) <= version and version < (11, 0): # Prior to Mac OS 11, each yearly release of Mac OS bumped the # "minor" version number. The major version was always 10. for minor_version in range(version[1], -1, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=10, minor=minor_version, binary_format=binary_format ) if version >= (11, 0): # Starting with Mac OS 11, each yearly release bumps the major version # number. The minor versions are now the midyear updates. for major_version in range(version[0], 10, -1): compat_version = major_version, 0 binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=major_version, minor=0, binary_format=binary_format ) if version >= (11, 0): # Mac OS 11 on x86_64 is compatible with binaries from previous releases. # Arm64 support was introduced in 11.0, so no Arm binaries from previous # releases exist. # # However, the "universal2" binary format can have a # macOS version earlier than 11.0 when the x86_64 part of the binary supports # that version of macOS. if arch == "x86_64": for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_formats = _mac_binary_formats(compat_version, arch) for binary_format in binary_formats: yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) else: for minor_version in range(16, 3, -1): compat_version = 10, minor_version binary_format = "universal2" yield "macosx_{major}_{minor}_{binary_format}".format( major=compat_version[0], minor=compat_version[1], binary_format=binary_format, ) def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]: linux = _normalize_string(sysconfig.get_platform()) if is_32bit: if linux == "linux_x86_64": linux = "linux_i686" elif linux == "linux_aarch64": linux = "linux_armv7l" _, arch = linux.split("_", 1) yield from _manylinux.platform_tags(linux, arch) yield from _musllinux.platform_tags(arch) yield linux def _generic_platforms() -> Iterator[str]: yield _normalize_string(sysconfig.get_platform()) def platform_tags() -> Iterator[str]: """ Provides the platform tags for this installation. """ if platform.system() == "Darwin": return mac_platforms() elif platform.system() == "Linux": return _linux_platforms() else: return _generic_platforms() def interpreter_name() -> str: """ Returns the name of the running interpreter. Some implementations have a reserved, two-letter abbreviation which will be returned when appropriate. """ name = sys.implementation.name return INTERPRETER_SHORT_NAMES.get(name) or name def interpreter_version(*, warn: bool = False) -> str: """ Returns the version of the running interpreter. """ version = _get_config_var("py_version_nodot", warn=warn) if version: version = str(version) else: version = _version_nodot(sys.version_info[:2]) return version def _version_nodot(version: PythonVersion) -> str: return "".join(map(str, version)) def sys_tags(*, warn: bool = False) -> Iterator[Tag]: """ Returns the sequence of tag triples for the running interpreter. The order of the sequence corresponds to priority order for the interpreter, from most to least important. """ interp_name = interpreter_name() if interp_name == "cp": yield from cpython_tags(warn=warn) else: yield from generic_tags() if interp_name == "pp": interp = "pp3" elif interp_name == "cp": interp = "cp" + interpreter_version(warn=warn) else: interp = None yield from compatible_tags(interpreter=interp) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/utils.py0000644000175100001730000001040314467657412023415 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. import re from typing import FrozenSet, NewType, Tuple, Union, cast from .tags import Tag, parse_tag from .version import InvalidVersion, Version BuildTag = Union[Tuple[()], Tuple[int, str]] NormalizedName = NewType("NormalizedName", str) class InvalidWheelFilename(ValueError): """ An invalid wheel filename was found, users should refer to PEP 427. """ class InvalidSdistFilename(ValueError): """ An invalid sdist filename was found, users should refer to the packaging user guide. """ _canonicalize_regex = re.compile(r"[-_.]+") # PEP 427: The build number must start with a digit. _build_tag_regex = re.compile(r"(\d+)(.*)") def canonicalize_name(name: str) -> NormalizedName: # This is taken from PEP 503. value = _canonicalize_regex.sub("-", name).lower() return cast(NormalizedName, value) def canonicalize_version( version: Union[Version, str], *, strip_trailing_zero: bool = True ) -> str: """ This is very similar to Version.__str__, but has one subtle difference with the way it handles the release segment. """ if isinstance(version, str): try: parsed = Version(version) except InvalidVersion: # Legacy versions cannot be normalized return version else: parsed = version parts = [] # Epoch if parsed.epoch != 0: parts.append(f"{parsed.epoch}!") # Release segment release_segment = ".".join(str(x) for x in parsed.release) if strip_trailing_zero: # NB: This strips trailing '.0's to normalize release_segment = re.sub(r"(\.0)+$", "", release_segment) parts.append(release_segment) # Pre-release if parsed.pre is not None: parts.append("".join(str(x) for x in parsed.pre)) # Post-release if parsed.post is not None: parts.append(f".post{parsed.post}") # Development release if parsed.dev is not None: parts.append(f".dev{parsed.dev}") # Local version segment if parsed.local is not None: parts.append(f"+{parsed.local}") return "".join(parts) def parse_wheel_filename( filename: str, ) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]: if not filename.endswith(".whl"): raise InvalidWheelFilename( f"Invalid wheel filename (extension must be '.whl'): {filename}" ) filename = filename[:-4] dashes = filename.count("-") if dashes not in (4, 5): raise InvalidWheelFilename( f"Invalid wheel filename (wrong number of parts): {filename}" ) parts = filename.split("-", dashes - 2) name_part = parts[0] # See PEP 427 for the rules on escaping the project name if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None: raise InvalidWheelFilename(f"Invalid project name: {filename}") name = canonicalize_name(name_part) version = Version(parts[1]) if dashes == 5: build_part = parts[2] build_match = _build_tag_regex.match(build_part) if build_match is None: raise InvalidWheelFilename( f"Invalid build number: {build_part} in '{filename}'" ) build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2))) else: build = () tags = parse_tag(parts[-1]) return (name, version, build, tags) def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]: if filename.endswith(".tar.gz"): file_stem = filename[: -len(".tar.gz")] elif filename.endswith(".zip"): file_stem = filename[: -len(".zip")] else: raise InvalidSdistFilename( f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):" f" {filename}" ) # We are requiring a PEP 440 version, which cannot contain dashes, # so we split on the last dash. name_part, sep, version_part = file_stem.rpartition("-") if not sep: raise InvalidSdistFilename(f"Invalid sdist filename: {filename}") name = canonicalize_name(name_part) version = Version(version_part) return (name, version) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0 setuptools-68.1.2/pkg_resources/_vendor/packaging/version.py0000644000175100001730000003770614467657412023761 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version # 2.0, and the BSD License. See the LICENSE file in the root of this repository # for complete details. """ .. testsetup:: from packaging.version import parse, Version """ import collections import itertools import re from typing import Any, Callable, Optional, SupportsInt, Tuple, Union from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType __all__ = ["VERSION_PATTERN", "parse", "Version", "InvalidVersion"] InfiniteTypes = Union[InfinityType, NegativeInfinityType] PrePostDevType = Union[InfiniteTypes, Tuple[str, int]] SubLocalType = Union[InfiniteTypes, int, str] LocalType = Union[ NegativeInfinityType, Tuple[ Union[ SubLocalType, Tuple[SubLocalType, str], Tuple[NegativeInfinityType, SubLocalType], ], ..., ], ] CmpKey = Tuple[ int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType ] VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool] _Version = collections.namedtuple( "_Version", ["epoch", "release", "dev", "pre", "post", "local"] ) def parse(version: str) -> "Version": """Parse the given version string. >>> parse('1.0.dev1') :param version: The version string to parse. :raises InvalidVersion: When the version string is not a valid version. """ return Version(version) class InvalidVersion(ValueError): """Raised when a version string is not a valid version. >>> Version("invalid") Traceback (most recent call last): ... packaging.version.InvalidVersion: Invalid version: 'invalid' """ class _BaseVersion: _key: Tuple[Any, ...] def __hash__(self) -> int: return hash(self._key) # Please keep the duplicated `isinstance` check # in the six comparisons hereunder # unless you find a way to avoid adding overhead function calls. def __lt__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key < other._key def __le__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key <= other._key def __eq__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key == other._key def __ge__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key >= other._key def __gt__(self, other: "_BaseVersion") -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key > other._key def __ne__(self, other: object) -> bool: if not isinstance(other, _BaseVersion): return NotImplemented return self._key != other._key # Deliberately not anchored to the start and end of the string, to make it # easier for 3rd party code to reuse _VERSION_PATTERN = r""" v? (?: (?:(?P[0-9]+)!)? # epoch (?P[0-9]+(?:\.[0-9]+)*) # release segment (?P
                                          # pre-release
            [-_\.]?
            (?P(a|b|c|rc|alpha|beta|pre|preview))
            [-_\.]?
            (?P[0-9]+)?
        )?
        (?P                                         # post release
            (?:-(?P[0-9]+))
            |
            (?:
                [-_\.]?
                (?Ppost|rev|r)
                [-_\.]?
                (?P[0-9]+)?
            )
        )?
        (?P                                          # dev release
            [-_\.]?
            (?Pdev)
            [-_\.]?
            (?P[0-9]+)?
        )?
    )
    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
"""

VERSION_PATTERN = _VERSION_PATTERN
"""
A string containing the regular expression used to match a valid version.

The pattern is not anchored at either end, and is intended for embedding in larger
expressions (for example, matching a version number as part of a file name). The
regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
flags set.

:meta hide-value:
"""


class Version(_BaseVersion):
    """This class abstracts handling of a project's versions.

    A :class:`Version` instance is comparison aware and can be compared and
    sorted using the standard Python interfaces.

    >>> v1 = Version("1.0a5")
    >>> v2 = Version("1.0")
    >>> v1
    
    >>> v2
    
    >>> v1 < v2
    True
    >>> v1 == v2
    False
    >>> v1 > v2
    False
    >>> v1 >= v2
    False
    >>> v1 <= v2
    True
    """

    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
    _key: CmpKey

    def __init__(self, version: str) -> None:
        """Initialize a Version object.

        :param version:
            The string representation of a version which will be parsed and normalized
            before use.
        :raises InvalidVersion:
            If the ``version`` does not conform to PEP 440 in any way then this
            exception will be raised.
        """

        # Validate the version and parse it into pieces
        match = self._regex.search(version)
        if not match:
            raise InvalidVersion(f"Invalid version: '{version}'")

        # Store the parsed out pieces of the version
        self._version = _Version(
            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
            release=tuple(int(i) for i in match.group("release").split(".")),
            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
            post=_parse_letter_version(
                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
            ),
            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
            local=_parse_local_version(match.group("local")),
        )

        # Generate a key which will be used for sorting
        self._key = _cmpkey(
            self._version.epoch,
            self._version.release,
            self._version.pre,
            self._version.post,
            self._version.dev,
            self._version.local,
        )

    def __repr__(self) -> str:
        """A representation of the Version that shows all internal state.

        >>> Version('1.0.0')
        
        """
        return f""

    def __str__(self) -> str:
        """A string representation of the version that can be rounded-tripped.

        >>> str(Version("1.0a5"))
        '1.0a5'
        """
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        # Pre-release
        if self.pre is not None:
            parts.append("".join(str(x) for x in self.pre))

        # Post-release
        if self.post is not None:
            parts.append(f".post{self.post}")

        # Development release
        if self.dev is not None:
            parts.append(f".dev{self.dev}")

        # Local version segment
        if self.local is not None:
            parts.append(f"+{self.local}")

        return "".join(parts)

    @property
    def epoch(self) -> int:
        """The epoch of the version.

        >>> Version("2.0.0").epoch
        0
        >>> Version("1!2.0.0").epoch
        1
        """
        _epoch: int = self._version.epoch
        return _epoch

    @property
    def release(self) -> Tuple[int, ...]:
        """The components of the "release" segment of the version.

        >>> Version("1.2.3").release
        (1, 2, 3)
        >>> Version("2.0.0").release
        (2, 0, 0)
        >>> Version("1!2.0.0.post0").release
        (2, 0, 0)

        Includes trailing zeroes but not the epoch or any pre-release / development /
        post-release suffixes.
        """
        _release: Tuple[int, ...] = self._version.release
        return _release

    @property
    def pre(self) -> Optional[Tuple[str, int]]:
        """The pre-release segment of the version.

        >>> print(Version("1.2.3").pre)
        None
        >>> Version("1.2.3a1").pre
        ('a', 1)
        >>> Version("1.2.3b1").pre
        ('b', 1)
        >>> Version("1.2.3rc1").pre
        ('rc', 1)
        """
        _pre: Optional[Tuple[str, int]] = self._version.pre
        return _pre

    @property
    def post(self) -> Optional[int]:
        """The post-release number of the version.

        >>> print(Version("1.2.3").post)
        None
        >>> Version("1.2.3.post1").post
        1
        """
        return self._version.post[1] if self._version.post else None

    @property
    def dev(self) -> Optional[int]:
        """The development number of the version.

        >>> print(Version("1.2.3").dev)
        None
        >>> Version("1.2.3.dev1").dev
        1
        """
        return self._version.dev[1] if self._version.dev else None

    @property
    def local(self) -> Optional[str]:
        """The local version segment of the version.

        >>> print(Version("1.2.3").local)
        None
        >>> Version("1.2.3+abc").local
        'abc'
        """
        if self._version.local:
            return ".".join(str(x) for x in self._version.local)
        else:
            return None

    @property
    def public(self) -> str:
        """The public portion of the version.

        >>> Version("1.2.3").public
        '1.2.3'
        >>> Version("1.2.3+abc").public
        '1.2.3'
        >>> Version("1.2.3+abc.dev1").public
        '1.2.3'
        """
        return str(self).split("+", 1)[0]

    @property
    def base_version(self) -> str:
        """The "base version" of the version.

        >>> Version("1.2.3").base_version
        '1.2.3'
        >>> Version("1.2.3+abc").base_version
        '1.2.3'
        >>> Version("1!1.2.3+abc.dev1").base_version
        '1!1.2.3'

        The "base version" is the public version of the project without any pre or post
        release markers.
        """
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        return "".join(parts)

    @property
    def is_prerelease(self) -> bool:
        """Whether this version is a pre-release.

        >>> Version("1.2.3").is_prerelease
        False
        >>> Version("1.2.3a1").is_prerelease
        True
        >>> Version("1.2.3b1").is_prerelease
        True
        >>> Version("1.2.3rc1").is_prerelease
        True
        >>> Version("1.2.3dev1").is_prerelease
        True
        """
        return self.dev is not None or self.pre is not None

    @property
    def is_postrelease(self) -> bool:
        """Whether this version is a post-release.

        >>> Version("1.2.3").is_postrelease
        False
        >>> Version("1.2.3.post1").is_postrelease
        True
        """
        return self.post is not None

    @property
    def is_devrelease(self) -> bool:
        """Whether this version is a development release.

        >>> Version("1.2.3").is_devrelease
        False
        >>> Version("1.2.3.dev1").is_devrelease
        True
        """
        return self.dev is not None

    @property
    def major(self) -> int:
        """The first item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").major
        1
        """
        return self.release[0] if len(self.release) >= 1 else 0

    @property
    def minor(self) -> int:
        """The second item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").minor
        2
        >>> Version("1").minor
        0
        """
        return self.release[1] if len(self.release) >= 2 else 0

    @property
    def micro(self) -> int:
        """The third item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").micro
        3
        >>> Version("1").micro
        0
        """
        return self.release[2] if len(self.release) >= 3 else 0


def _parse_letter_version(
    letter: str, number: Union[str, bytes, SupportsInt]
) -> Optional[Tuple[str, int]]:

    if letter:
        # We consider there to be an implicit 0 in a pre-release if there is
        # not a numeral associated with it.
        if number is None:
            number = 0

        # We normalize any letters to their lower case form
        letter = letter.lower()

        # We consider some words to be alternate spellings of other words and
        # in those cases we want to normalize the spellings to our preferred
        # spelling.
        if letter == "alpha":
            letter = "a"
        elif letter == "beta":
            letter = "b"
        elif letter in ["c", "pre", "preview"]:
            letter = "rc"
        elif letter in ["rev", "r"]:
            letter = "post"

        return letter, int(number)
    if not letter and number:
        # We assume if we are given a number, but we are not given a letter
        # then this is using the implicit post release syntax (e.g. 1.0-1)
        letter = "post"

        return letter, int(number)

    return None


_local_version_separators = re.compile(r"[\._-]")


def _parse_local_version(local: str) -> Optional[LocalType]:
    """
    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
    """
    if local is not None:
        return tuple(
            part.lower() if not part.isdigit() else int(part)
            for part in _local_version_separators.split(local)
        )
    return None


def _cmpkey(
    epoch: int,
    release: Tuple[int, ...],
    pre: Optional[Tuple[str, int]],
    post: Optional[Tuple[str, int]],
    dev: Optional[Tuple[str, int]],
    local: Optional[Tuple[SubLocalType]],
) -> CmpKey:

    # When we compare a release version, we want to compare it with all of the
    # trailing zeros removed. So we'll use a reverse the list, drop all the now
    # leading zeros until we come to something non zero, then take the rest
    # re-reverse it back into the correct order and make it a tuple and use
    # that for our sorting key.
    _release = tuple(
        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
    )

    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
    # We'll do this by abusing the pre segment, but we _only_ want to do this
    # if there is not a pre or a post segment. If we have one of those then
    # the normal sorting rules will handle this case correctly.
    if pre is None and post is None and dev is not None:
        _pre: PrePostDevType = NegativeInfinity
    # Versions without a pre-release (except as noted above) should sort after
    # those with one.
    elif pre is None:
        _pre = Infinity
    else:
        _pre = pre

    # Versions without a post segment should sort before those with one.
    if post is None:
        _post: PrePostDevType = NegativeInfinity

    else:
        _post = post

    # Versions without a development segment should sort after those with one.
    if dev is None:
        _dev: PrePostDevType = Infinity

    else:
        _dev = dev

    if local is None:
        # Versions without a local segment should sort before those with one.
        _local: LocalType = NegativeInfinity
    else:
        # Versions with a local segment need that segment parsed to implement
        # the sorting rules in PEP440.
        # - Alpha numeric segments sort before numeric segments
        # - Alpha numeric segments sort lexicographically
        # - Numeric segments sort numerically
        # - Shorter versions sort before longer versions when the prefixes
        #   match exactly
        _local = tuple(
            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
        )

    return epoch, _release, _pre, _post, _dev, _local
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4995484
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/0000755000175100001730000000000014467657443022473 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/__init__.py0000644000175100001730000003100614467657412024600 0ustar00runnerdocker"""
Utilities for determining application-specific dirs. See  for details and
usage.
"""
from __future__ import annotations

import os
import sys
from pathlib import Path

if sys.version_info >= (3, 8):  # pragma: no cover (py38+)
    from typing import Literal
else:  # pragma: no cover (py38+)
    from ..typing_extensions import Literal

from .api import PlatformDirsABC
from .version import __version__
from .version import __version_tuple__ as __version_info__


def _set_platform_dir_class() -> type[PlatformDirsABC]:
    if sys.platform == "win32":
        from .windows import Windows as Result
    elif sys.platform == "darwin":
        from .macos import MacOS as Result
    else:
        from .unix import Unix as Result

    if os.getenv("ANDROID_DATA") == "/data" and os.getenv("ANDROID_ROOT") == "/system":

        if os.getenv("SHELL") or os.getenv("PREFIX"):
            return Result

        from .android import _android_folder

        if _android_folder() is not None:
            from .android import Android

            return Android  # return to avoid redefinition of result

    return Result


PlatformDirs = _set_platform_dir_class()  #: Currently active platform
AppDirs = PlatformDirs  #: Backwards compatibility with appdirs


def user_data_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    roaming: bool = False,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param roaming: See `roaming `.
    :returns: data directory tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_dir


def site_data_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    multipath: bool = False,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param multipath: See `roaming `.
    :returns: data directory shared by users
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_dir


def user_config_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    roaming: bool = False,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param roaming: See `roaming `.
    :returns: config directory tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_dir


def site_config_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    multipath: bool = False,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param multipath: See `roaming `.
    :returns: config directory shared by the users
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_dir


def user_cache_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    opinion: bool = True,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param opinion: See `roaming `.
    :returns: cache directory tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_cache_dir


def user_state_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    roaming: bool = False,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param roaming: See `roaming `.
    :returns: state directory tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_state_dir


def user_log_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    opinion: bool = True,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param opinion: See `roaming `.
    :returns: log directory tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_log_dir


def user_documents_dir() -> str:
    """
    :returns: documents directory tied to the user
    """
    return PlatformDirs().user_documents_dir


def user_runtime_dir(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    opinion: bool = True,
) -> str:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param opinion: See `opinion `.
    :returns: runtime directory tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_dir


def user_data_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    roaming: bool = False,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param roaming: See `roaming `.
    :returns: data path tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_data_path


def site_data_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    multipath: bool = False,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param multipath: See `multipath `.
    :returns: data path shared by users
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_data_path


def user_config_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    roaming: bool = False,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param roaming: See `roaming `.
    :returns: config path tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_config_path


def site_config_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    multipath: bool = False,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param multipath: See `roaming `.
    :returns: config path shared by the users
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, multipath=multipath).site_config_path


def user_cache_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    opinion: bool = True,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param opinion: See `roaming `.
    :returns: cache path tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_cache_path


def user_state_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    roaming: bool = False,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param roaming: See `roaming `.
    :returns: state path tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, roaming=roaming).user_state_path


def user_log_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    opinion: bool = True,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param opinion: See `roaming `.
    :returns: log path tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_log_path


def user_documents_path() -> Path:
    """
    :returns: documents path tied to the user
    """
    return PlatformDirs().user_documents_path


def user_runtime_path(
    appname: str | None = None,
    appauthor: str | None | Literal[False] = None,
    version: str | None = None,
    opinion: bool = True,
) -> Path:
    """
    :param appname: See `appname `.
    :param appauthor: See `appauthor `.
    :param version: See `version `.
    :param opinion: See `opinion `.
    :returns: runtime path tied to the user
    """
    return PlatformDirs(appname=appname, appauthor=appauthor, version=version, opinion=opinion).user_runtime_path


__all__ = [
    "__version__",
    "__version_info__",
    "PlatformDirs",
    "AppDirs",
    "PlatformDirsABC",
    "user_data_dir",
    "user_config_dir",
    "user_cache_dir",
    "user_state_dir",
    "user_log_dir",
    "user_documents_dir",
    "user_runtime_dir",
    "site_data_dir",
    "site_config_dir",
    "user_data_path",
    "user_config_path",
    "user_cache_path",
    "user_state_path",
    "user_log_path",
    "user_documents_path",
    "user_runtime_path",
    "site_data_path",
    "site_config_path",
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/__main__.py0000644000175100001730000000221414467657412024560 0ustar00runnerdockerfrom __future__ import annotations

from platformdirs import PlatformDirs, __version__

PROPS = (
    "user_data_dir",
    "user_config_dir",
    "user_cache_dir",
    "user_state_dir",
    "user_log_dir",
    "user_documents_dir",
    "user_runtime_dir",
    "site_data_dir",
    "site_config_dir",
)


def main() -> None:
    app_name = "MyApp"
    app_author = "MyCompany"

    print(f"-- platformdirs {__version__} --")

    print("-- app dirs (with optional 'version')")
    dirs = PlatformDirs(app_name, app_author, version="1.0")
    for prop in PROPS:
        print(f"{prop}: {getattr(dirs, prop)}")

    print("\n-- app dirs (without optional 'version')")
    dirs = PlatformDirs(app_name, app_author)
    for prop in PROPS:
        print(f"{prop}: {getattr(dirs, prop)}")

    print("\n-- app dirs (without optional 'appauthor')")
    dirs = PlatformDirs(app_name)
    for prop in PROPS:
        print(f"{prop}: {getattr(dirs, prop)}")

    print("\n-- app dirs (with disabled 'appauthor')")
    dirs = PlatformDirs(app_name, appauthor=False)
    for prop in PROPS:
        print(f"{prop}: {getattr(dirs, prop)}")


if __name__ == "__main__":
    main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/android.py0000644000175100001730000000774414467657412024475 0ustar00runnerdockerfrom __future__ import annotations

import os
import re
import sys
from functools import lru_cache
from typing import cast

from .api import PlatformDirsABC


class Android(PlatformDirsABC):
    """
    Follows the guidance `from here `_. Makes use of the
    `appname ` and
    `version `.
    """

    @property
    def user_data_dir(self) -> str:
        """:return: data directory tied to the user, e.g. ``/data/user///files/``"""
        return self._append_app_name_and_version(cast(str, _android_folder()), "files")

    @property
    def site_data_dir(self) -> str:
        """:return: data directory shared by users, same as `user_data_dir`"""
        return self.user_data_dir

    @property
    def user_config_dir(self) -> str:
        """
        :return: config directory tied to the user, e.g. ``/data/user///shared_prefs/``
        """
        return self._append_app_name_and_version(cast(str, _android_folder()), "shared_prefs")

    @property
    def site_config_dir(self) -> str:
        """:return: config directory shared by the users, same as `user_config_dir`"""
        return self.user_config_dir

    @property
    def user_cache_dir(self) -> str:
        """:return: cache directory tied to the user, e.g. e.g. ``/data/user///cache/``"""
        return self._append_app_name_and_version(cast(str, _android_folder()), "cache")

    @property
    def user_state_dir(self) -> str:
        """:return: state directory tied to the user, same as `user_data_dir`"""
        return self.user_data_dir

    @property
    def user_log_dir(self) -> str:
        """
        :return: log directory tied to the user, same as `user_cache_dir` if not opinionated else ``log`` in it,
          e.g. ``/data/user///cache//log``
        """
        path = self.user_cache_dir
        if self.opinion:
            path = os.path.join(path, "log")
        return path

    @property
    def user_documents_dir(self) -> str:
        """
        :return: documents directory tied to the user e.g. ``/storage/emulated/0/Documents``
        """
        return _android_documents_folder()

    @property
    def user_runtime_dir(self) -> str:
        """
        :return: runtime directory tied to the user, same as `user_cache_dir` if not opinionated else ``tmp`` in it,
          e.g. ``/data/user///cache//tmp``
        """
        path = self.user_cache_dir
        if self.opinion:
            path = os.path.join(path, "tmp")
        return path


@lru_cache(maxsize=1)
def _android_folder() -> str | None:
    """:return: base folder for the Android OS or None if cannot be found"""
    try:
        # First try to get path to android app via pyjnius
        from jnius import autoclass

        Context = autoclass("android.content.Context")  # noqa: N806
        result: str | None = Context.getFilesDir().getParentFile().getAbsolutePath()
    except Exception:
        # if fails find an android folder looking path on the sys.path
        pattern = re.compile(r"/data/(data|user/\d+)/(.+)/files")
        for path in sys.path:
            if pattern.match(path):
                result = path.split("/files")[0]
                break
        else:
            result = None
    return result


@lru_cache(maxsize=1)
def _android_documents_folder() -> str:
    """:return: documents folder for the Android OS"""
    # Get directories with pyjnius
    try:
        from jnius import autoclass

        Context = autoclass("android.content.Context")  # noqa: N806
        Environment = autoclass("android.os.Environment")  # noqa: N806
        documents_dir: str = Context.getExternalFilesDir(Environment.DIRECTORY_DOCUMENTS).getAbsolutePath()
    except Exception:
        documents_dir = "/storage/emulated/0/Documents"

    return documents_dir


__all__ = [
    "Android",
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/api.py0000644000175100001730000001145614467657412023621 0ustar00runnerdockerfrom __future__ import annotations

import os
import sys
from abc import ABC, abstractmethod
from pathlib import Path

if sys.version_info >= (3, 8):  # pragma: no branch
    from typing import Literal  # pragma: no cover


class PlatformDirsABC(ABC):
    """
    Abstract base class for platform directories.
    """

    def __init__(
        self,
        appname: str | None = None,
        appauthor: str | None | Literal[False] = None,
        version: str | None = None,
        roaming: bool = False,
        multipath: bool = False,
        opinion: bool = True,
    ):
        """
        Create a new platform directory.

        :param appname: See `appname`.
        :param appauthor: See `appauthor`.
        :param version: See `version`.
        :param roaming: See `roaming`.
        :param multipath: See `multipath`.
        :param opinion: See `opinion`.
        """
        self.appname = appname  #: The name of application.
        self.appauthor = appauthor
        """
        The name of the app author or distributing body for this application. Typically, it is the owning company name.
        Defaults to `appname`. You may pass ``False`` to disable it.
        """
        self.version = version
        """
        An optional version path element to append to the path. You might want to use this if you want multiple versions
        of your app to be able to run independently. If used, this would typically be ``.``.
        """
        self.roaming = roaming
        """
        Whether to use the roaming appdata directory on Windows. That means that for users on a Windows network setup
        for roaming profiles, this user data will be synced on login (see
        `here `_).
        """
        self.multipath = multipath
        """
        An optional parameter only applicable to Unix/Linux which indicates that the entire list of data dirs should be
        returned. By default, the first item would only be returned.
        """
        self.opinion = opinion  #: A flag to indicating to use opinionated values.

    def _append_app_name_and_version(self, *base: str) -> str:
        params = list(base[1:])
        if self.appname:
            params.append(self.appname)
            if self.version:
                params.append(self.version)
        return os.path.join(base[0], *params)

    @property
    @abstractmethod
    def user_data_dir(self) -> str:
        """:return: data directory tied to the user"""

    @property
    @abstractmethod
    def site_data_dir(self) -> str:
        """:return: data directory shared by users"""

    @property
    @abstractmethod
    def user_config_dir(self) -> str:
        """:return: config directory tied to the user"""

    @property
    @abstractmethod
    def site_config_dir(self) -> str:
        """:return: config directory shared by the users"""

    @property
    @abstractmethod
    def user_cache_dir(self) -> str:
        """:return: cache directory tied to the user"""

    @property
    @abstractmethod
    def user_state_dir(self) -> str:
        """:return: state directory tied to the user"""

    @property
    @abstractmethod
    def user_log_dir(self) -> str:
        """:return: log directory tied to the user"""

    @property
    @abstractmethod
    def user_documents_dir(self) -> str:
        """:return: documents directory tied to the user"""

    @property
    @abstractmethod
    def user_runtime_dir(self) -> str:
        """:return: runtime directory tied to the user"""

    @property
    def user_data_path(self) -> Path:
        """:return: data path tied to the user"""
        return Path(self.user_data_dir)

    @property
    def site_data_path(self) -> Path:
        """:return: data path shared by users"""
        return Path(self.site_data_dir)

    @property
    def user_config_path(self) -> Path:
        """:return: config path tied to the user"""
        return Path(self.user_config_dir)

    @property
    def site_config_path(self) -> Path:
        """:return: config path shared by the users"""
        return Path(self.site_config_dir)

    @property
    def user_cache_path(self) -> Path:
        """:return: cache path tied to the user"""
        return Path(self.user_cache_dir)

    @property
    def user_state_path(self) -> Path:
        """:return: state path tied to the user"""
        return Path(self.user_state_dir)

    @property
    def user_log_path(self) -> Path:
        """:return: log path tied to the user"""
        return Path(self.user_log_dir)

    @property
    def user_documents_path(self) -> Path:
        """:return: documents path tied to the user"""
        return Path(self.user_documents_dir)

    @property
    def user_runtime_path(self) -> Path:
        """:return: runtime path tied to the user"""
        return Path(self.user_runtime_dir)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/macos.py0000644000175100001730000000513714467657412024151 0ustar00runnerdockerfrom __future__ import annotations

import os

from .api import PlatformDirsABC


class MacOS(PlatformDirsABC):
    """
    Platform directories for the macOS operating system. Follows the guidance from `Apple documentation
    `_.
    Makes use of the `appname ` and
    `version `.
    """

    @property
    def user_data_dir(self) -> str:
        """:return: data directory tied to the user, e.g. ``~/Library/Application Support/$appname/$version``"""
        return self._append_app_name_and_version(os.path.expanduser("~/Library/Application Support/"))

    @property
    def site_data_dir(self) -> str:
        """:return: data directory shared by users, e.g. ``/Library/Application Support/$appname/$version``"""
        return self._append_app_name_and_version("/Library/Application Support")

    @property
    def user_config_dir(self) -> str:
        """:return: config directory tied to the user, e.g. ``~/Library/Preferences/$appname/$version``"""
        return self._append_app_name_and_version(os.path.expanduser("~/Library/Preferences/"))

    @property
    def site_config_dir(self) -> str:
        """:return: config directory shared by the users, e.g. ``/Library/Preferences/$appname``"""
        return self._append_app_name_and_version("/Library/Preferences")

    @property
    def user_cache_dir(self) -> str:
        """:return: cache directory tied to the user, e.g. ``~/Library/Caches/$appname/$version``"""
        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches"))

    @property
    def user_state_dir(self) -> str:
        """:return: state directory tied to the user, same as `user_data_dir`"""
        return self.user_data_dir

    @property
    def user_log_dir(self) -> str:
        """:return: log directory tied to the user, e.g. ``~/Library/Logs/$appname/$version``"""
        return self._append_app_name_and_version(os.path.expanduser("~/Library/Logs"))

    @property
    def user_documents_dir(self) -> str:
        """:return: documents directory tied to the user, e.g. ``~/Documents``"""
        return os.path.expanduser("~/Documents")

    @property
    def user_runtime_dir(self) -> str:
        """:return: runtime directory tied to the user, e.g. ``~/Library/Caches/TemporaryItems/$appname/$version``"""
        return self._append_app_name_and_version(os.path.expanduser("~/Library/Caches/TemporaryItems"))


__all__ = [
    "MacOS",
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/unix.py0000644000175100001730000001537714467657412024041 0ustar00runnerdockerfrom __future__ import annotations

import os
import sys
from configparser import ConfigParser
from pathlib import Path

from .api import PlatformDirsABC

if sys.platform.startswith("linux"):  # pragma: no branch # no op check, only to please the type checker
    from os import getuid
else:

    def getuid() -> int:
        raise RuntimeError("should only be used on Linux")


class Unix(PlatformDirsABC):
    """
    On Unix/Linux, we follow the
    `XDG Basedir Spec `_. The spec allows
    overriding directories with environment variables. The examples show are the default values, alongside the name of
    the environment variable that overrides them. Makes use of the
    `appname `,
    `version `,
    `multipath `,
    `opinion `.
    """

    @property
    def user_data_dir(self) -> str:
        """
        :return: data directory tied to the user, e.g. ``~/.local/share/$appname/$version`` or
         ``$XDG_DATA_HOME/$appname/$version``
        """
        path = os.environ.get("XDG_DATA_HOME", "")
        if not path.strip():
            path = os.path.expanduser("~/.local/share")
        return self._append_app_name_and_version(path)

    @property
    def site_data_dir(self) -> str:
        """
        :return: data directories shared by users (if `multipath ` is
         enabled and ``XDG_DATA_DIR`` is set and a multi path the response is also a multi path separated by the OS
         path separator), e.g. ``/usr/local/share/$appname/$version`` or ``/usr/share/$appname/$version``
        """
        # XDG default for $XDG_DATA_DIRS; only first, if multipath is False
        path = os.environ.get("XDG_DATA_DIRS", "")
        if not path.strip():
            path = f"/usr/local/share{os.pathsep}/usr/share"
        return self._with_multi_path(path)

    def _with_multi_path(self, path: str) -> str:
        path_list = path.split(os.pathsep)
        if not self.multipath:
            path_list = path_list[0:1]
        path_list = [self._append_app_name_and_version(os.path.expanduser(p)) for p in path_list]
        return os.pathsep.join(path_list)

    @property
    def user_config_dir(self) -> str:
        """
        :return: config directory tied to the user, e.g. ``~/.config/$appname/$version`` or
         ``$XDG_CONFIG_HOME/$appname/$version``
        """
        path = os.environ.get("XDG_CONFIG_HOME", "")
        if not path.strip():
            path = os.path.expanduser("~/.config")
        return self._append_app_name_and_version(path)

    @property
    def site_config_dir(self) -> str:
        """
        :return: config directories shared by users (if `multipath `
         is enabled and ``XDG_DATA_DIR`` is set and a multi path the response is also a multi path separated by the OS
         path separator), e.g. ``/etc/xdg/$appname/$version``
        """
        # XDG default for $XDG_CONFIG_DIRS only first, if multipath is False
        path = os.environ.get("XDG_CONFIG_DIRS", "")
        if not path.strip():
            path = "/etc/xdg"
        return self._with_multi_path(path)

    @property
    def user_cache_dir(self) -> str:
        """
        :return: cache directory tied to the user, e.g. ``~/.cache/$appname/$version`` or
         ``~/$XDG_CACHE_HOME/$appname/$version``
        """
        path = os.environ.get("XDG_CACHE_HOME", "")
        if not path.strip():
            path = os.path.expanduser("~/.cache")
        return self._append_app_name_and_version(path)

    @property
    def user_state_dir(self) -> str:
        """
        :return: state directory tied to the user, e.g. ``~/.local/state/$appname/$version`` or
         ``$XDG_STATE_HOME/$appname/$version``
        """
        path = os.environ.get("XDG_STATE_HOME", "")
        if not path.strip():
            path = os.path.expanduser("~/.local/state")
        return self._append_app_name_and_version(path)

    @property
    def user_log_dir(self) -> str:
        """
        :return: log directory tied to the user, same as `user_state_dir` if not opinionated else ``log`` in it
        """
        path = self.user_state_dir
        if self.opinion:
            path = os.path.join(path, "log")
        return path

    @property
    def user_documents_dir(self) -> str:
        """
        :return: documents directory tied to the user, e.g. ``~/Documents``
        """
        documents_dir = _get_user_dirs_folder("XDG_DOCUMENTS_DIR")
        if documents_dir is None:
            documents_dir = os.environ.get("XDG_DOCUMENTS_DIR", "").strip()
            if not documents_dir:
                documents_dir = os.path.expanduser("~/Documents")

        return documents_dir

    @property
    def user_runtime_dir(self) -> str:
        """
        :return: runtime directory tied to the user, e.g. ``/run/user/$(id -u)/$appname/$version`` or
         ``$XDG_RUNTIME_DIR/$appname/$version``
        """
        path = os.environ.get("XDG_RUNTIME_DIR", "")
        if not path.strip():
            path = f"/run/user/{getuid()}"
        return self._append_app_name_and_version(path)

    @property
    def site_data_path(self) -> Path:
        """:return: data path shared by users. Only return first item, even if ``multipath`` is set to ``True``"""
        return self._first_item_as_path_if_multipath(self.site_data_dir)

    @property
    def site_config_path(self) -> Path:
        """:return: config path shared by the users. Only return first item, even if ``multipath`` is set to ``True``"""
        return self._first_item_as_path_if_multipath(self.site_config_dir)

    def _first_item_as_path_if_multipath(self, directory: str) -> Path:
        if self.multipath:
            # If multipath is True, the first path is returned.
            directory = directory.split(os.pathsep)[0]
        return Path(directory)


def _get_user_dirs_folder(key: str) -> str | None:
    """Return directory from user-dirs.dirs config file. See https://freedesktop.org/wiki/Software/xdg-user-dirs/"""
    user_dirs_config_path = os.path.join(Unix().user_config_dir, "user-dirs.dirs")
    if os.path.exists(user_dirs_config_path):
        parser = ConfigParser()

        with open(user_dirs_config_path) as stream:
            # Add fake section header, so ConfigParser doesn't complain
            parser.read_string(f"[top]\n{stream.read()}")

        if key not in parser["top"]:
            return None

        path = parser["top"][key].strip('"')
        # Handle relative home paths
        path = path.replace("$HOME", os.path.expanduser("~"))
        return path

    return None


__all__ = [
    "Unix",
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/version.py0000644000175100001730000000024014467657412024522 0ustar00runnerdocker# file generated by setuptools_scm
# don't change, don't track in version control
__version__ = version = '2.6.2'
__version_tuple__ = version_tuple = (2, 6, 2)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/platformdirs/windows.py0000644000175100001730000001470414467657412024541 0ustar00runnerdockerfrom __future__ import annotations

import ctypes
import os
import sys
from functools import lru_cache
from typing import Callable

from .api import PlatformDirsABC


class Windows(PlatformDirsABC):
    """`MSDN on where to store app data files
    `_.
    Makes use of the
    `appname `,
    `appauthor `,
    `version `,
    `roaming `,
    `opinion `."""

    @property
    def user_data_dir(self) -> str:
        """
        :return: data directory tied to the user, e.g.
         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname`` (not roaming) or
         ``%USERPROFILE%\\AppData\\Roaming\\$appauthor\\$appname`` (roaming)
        """
        const = "CSIDL_APPDATA" if self.roaming else "CSIDL_LOCAL_APPDATA"
        path = os.path.normpath(get_win_folder(const))
        return self._append_parts(path)

    def _append_parts(self, path: str, *, opinion_value: str | None = None) -> str:
        params = []
        if self.appname:
            if self.appauthor is not False:
                author = self.appauthor or self.appname
                params.append(author)
            params.append(self.appname)
            if opinion_value is not None and self.opinion:
                params.append(opinion_value)
            if self.version:
                params.append(self.version)
        return os.path.join(path, *params)

    @property
    def site_data_dir(self) -> str:
        """:return: data directory shared by users, e.g. ``C:\\ProgramData\\$appauthor\\$appname``"""
        path = os.path.normpath(get_win_folder("CSIDL_COMMON_APPDATA"))
        return self._append_parts(path)

    @property
    def user_config_dir(self) -> str:
        """:return: config directory tied to the user, same as `user_data_dir`"""
        return self.user_data_dir

    @property
    def site_config_dir(self) -> str:
        """:return: config directory shared by the users, same as `site_data_dir`"""
        return self.site_data_dir

    @property
    def user_cache_dir(self) -> str:
        """
        :return: cache directory tied to the user (if opinionated with ``Cache`` folder within ``$appname``) e.g.
         ``%USERPROFILE%\\AppData\\Local\\$appauthor\\$appname\\Cache\\$version``
        """
        path = os.path.normpath(get_win_folder("CSIDL_LOCAL_APPDATA"))
        return self._append_parts(path, opinion_value="Cache")

    @property
    def user_state_dir(self) -> str:
        """:return: state directory tied to the user, same as `user_data_dir`"""
        return self.user_data_dir

    @property
    def user_log_dir(self) -> str:
        """
        :return: log directory tied to the user, same as `user_data_dir` if not opinionated else ``Logs`` in it
        """
        path = self.user_data_dir
        if self.opinion:
            path = os.path.join(path, "Logs")
        return path

    @property
    def user_documents_dir(self) -> str:
        """
        :return: documents directory tied to the user e.g. ``%USERPROFILE%\\Documents``
        """
        return os.path.normpath(get_win_folder("CSIDL_PERSONAL"))

    @property
    def user_runtime_dir(self) -> str:
        """
        :return: runtime directory tied to the user, e.g.
         ``%USERPROFILE%\\AppData\\Local\\Temp\\$appauthor\\$appname``
        """
        path = os.path.normpath(os.path.join(get_win_folder("CSIDL_LOCAL_APPDATA"), "Temp"))
        return self._append_parts(path)


def get_win_folder_from_env_vars(csidl_name: str) -> str:
    """Get folder from environment variables."""
    if csidl_name == "CSIDL_PERSONAL":  # does not have an environment name
        return os.path.join(os.path.normpath(os.environ["USERPROFILE"]), "Documents")

    env_var_name = {
        "CSIDL_APPDATA": "APPDATA",
        "CSIDL_COMMON_APPDATA": "ALLUSERSPROFILE",
        "CSIDL_LOCAL_APPDATA": "LOCALAPPDATA",
    }.get(csidl_name)
    if env_var_name is None:
        raise ValueError(f"Unknown CSIDL name: {csidl_name}")
    result = os.environ.get(env_var_name)
    if result is None:
        raise ValueError(f"Unset environment variable: {env_var_name}")
    return result


def get_win_folder_from_registry(csidl_name: str) -> str:
    """Get folder from the registry.

    This is a fallback technique at best. I'm not sure if using the
    registry for this guarantees us the correct answer for all CSIDL_*
    names.
    """
    shell_folder_name = {
        "CSIDL_APPDATA": "AppData",
        "CSIDL_COMMON_APPDATA": "Common AppData",
        "CSIDL_LOCAL_APPDATA": "Local AppData",
        "CSIDL_PERSONAL": "Personal",
    }.get(csidl_name)
    if shell_folder_name is None:
        raise ValueError(f"Unknown CSIDL name: {csidl_name}")
    if sys.platform != "win32":  # only needed for mypy type checker to know that this code runs only on Windows
        raise NotImplementedError
    import winreg

    key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders")
    directory, _ = winreg.QueryValueEx(key, shell_folder_name)
    return str(directory)


def get_win_folder_via_ctypes(csidl_name: str) -> str:
    """Get folder with ctypes."""
    csidl_const = {
        "CSIDL_APPDATA": 26,
        "CSIDL_COMMON_APPDATA": 35,
        "CSIDL_LOCAL_APPDATA": 28,
        "CSIDL_PERSONAL": 5,
    }.get(csidl_name)
    if csidl_const is None:
        raise ValueError(f"Unknown CSIDL name: {csidl_name}")

    buf = ctypes.create_unicode_buffer(1024)
    windll = getattr(ctypes, "windll")  # noqa: B009 # using getattr to avoid false positive with mypy type checker
    windll.shell32.SHGetFolderPathW(None, csidl_const, None, 0, buf)

    # Downgrade to short path name if it has highbit chars.
    if any(ord(c) > 255 for c in buf):
        buf2 = ctypes.create_unicode_buffer(1024)
        if windll.kernel32.GetShortPathNameW(buf.value, buf2, 1024):
            buf = buf2

    return buf.value


def _pick_get_win_folder() -> Callable[[str], str]:
    if hasattr(ctypes, "windll"):
        return get_win_folder_via_ctypes
    try:
        import winreg  # noqa: F401
    except ImportError:
        return get_win_folder_from_env_vars
    else:
        return get_win_folder_from_registry


get_win_folder = lru_cache(maxsize=None)(_pick_get_win_folder())

__all__ = [
    "Windows",
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/typing_extensions.py0000644000175100001730000023431614467657412024135 0ustar00runnerdockerimport abc
import collections
import collections.abc
import functools
import operator
import sys
import types as _types
import typing


__all__ = [
    # Super-special typing primitives.
    'Any',
    'ClassVar',
    'Concatenate',
    'Final',
    'LiteralString',
    'ParamSpec',
    'ParamSpecArgs',
    'ParamSpecKwargs',
    'Self',
    'Type',
    'TypeVar',
    'TypeVarTuple',
    'Unpack',

    # ABCs (from collections.abc).
    'Awaitable',
    'AsyncIterator',
    'AsyncIterable',
    'Coroutine',
    'AsyncGenerator',
    'AsyncContextManager',
    'ChainMap',

    # Concrete collection types.
    'ContextManager',
    'Counter',
    'Deque',
    'DefaultDict',
    'NamedTuple',
    'OrderedDict',
    'TypedDict',

    # Structural checks, a.k.a. protocols.
    'SupportsIndex',

    # One-off things.
    'Annotated',
    'assert_never',
    'assert_type',
    'clear_overloads',
    'dataclass_transform',
    'get_overloads',
    'final',
    'get_args',
    'get_origin',
    'get_type_hints',
    'IntVar',
    'is_typeddict',
    'Literal',
    'NewType',
    'overload',
    'override',
    'Protocol',
    'reveal_type',
    'runtime',
    'runtime_checkable',
    'Text',
    'TypeAlias',
    'TypeGuard',
    'TYPE_CHECKING',
    'Never',
    'NoReturn',
    'Required',
    'NotRequired',
]

# for backward compatibility
PEP_560 = True
GenericMeta = type

# The functions below are modified copies of typing internal helpers.
# They are needed by _ProtocolMeta and they provide support for PEP 646.

_marker = object()


def _check_generic(cls, parameters, elen=_marker):
    """Check correct count for parameters of a generic cls (internal helper).
    This gives a nice error message in case of count mismatch.
    """
    if not elen:
        raise TypeError(f"{cls} is not a generic class")
    if elen is _marker:
        if not hasattr(cls, "__parameters__") or not cls.__parameters__:
            raise TypeError(f"{cls} is not a generic class")
        elen = len(cls.__parameters__)
    alen = len(parameters)
    if alen != elen:
        if hasattr(cls, "__parameters__"):
            parameters = [p for p in cls.__parameters__ if not _is_unpack(p)]
            num_tv_tuples = sum(isinstance(p, TypeVarTuple) for p in parameters)
            if (num_tv_tuples > 0) and (alen >= elen - num_tv_tuples):
                return
        raise TypeError(f"Too {'many' if alen > elen else 'few'} parameters for {cls};"
                        f" actual {alen}, expected {elen}")


if sys.version_info >= (3, 10):
    def _should_collect_from_parameters(t):
        return isinstance(
            t, (typing._GenericAlias, _types.GenericAlias, _types.UnionType)
        )
elif sys.version_info >= (3, 9):
    def _should_collect_from_parameters(t):
        return isinstance(t, (typing._GenericAlias, _types.GenericAlias))
else:
    def _should_collect_from_parameters(t):
        return isinstance(t, typing._GenericAlias) and not t._special


def _collect_type_vars(types, typevar_types=None):
    """Collect all type variable contained in types in order of
    first appearance (lexicographic order). For example::

        _collect_type_vars((T, List[S, T])) == (T, S)
    """
    if typevar_types is None:
        typevar_types = typing.TypeVar
    tvars = []
    for t in types:
        if (
            isinstance(t, typevar_types) and
            t not in tvars and
            not _is_unpack(t)
        ):
            tvars.append(t)
        if _should_collect_from_parameters(t):
            tvars.extend([t for t in t.__parameters__ if t not in tvars])
    return tuple(tvars)


NoReturn = typing.NoReturn

# Some unconstrained type variables.  These are used by the container types.
# (These are not for export.)
T = typing.TypeVar('T')  # Any type.
KT = typing.TypeVar('KT')  # Key type.
VT = typing.TypeVar('VT')  # Value type.
T_co = typing.TypeVar('T_co', covariant=True)  # Any type covariant containers.
T_contra = typing.TypeVar('T_contra', contravariant=True)  # Ditto contravariant.


if sys.version_info >= (3, 11):
    from typing import Any
else:

    class _AnyMeta(type):
        def __instancecheck__(self, obj):
            if self is Any:
                raise TypeError("typing_extensions.Any cannot be used with isinstance()")
            return super().__instancecheck__(obj)

        def __repr__(self):
            if self is Any:
                return "typing_extensions.Any"
            return super().__repr__()

    class Any(metaclass=_AnyMeta):
        """Special type indicating an unconstrained type.
        - Any is compatible with every type.
        - Any assumed to have all methods.
        - All values assumed to be instances of Any.
        Note that all the above statements are true from the point of view of
        static type checkers. At runtime, Any should not be used with instance
        checks.
        """
        def __new__(cls, *args, **kwargs):
            if cls is Any:
                raise TypeError("Any cannot be instantiated")
            return super().__new__(cls, *args, **kwargs)


ClassVar = typing.ClassVar

# On older versions of typing there is an internal class named "Final".
# 3.8+
if hasattr(typing, 'Final') and sys.version_info[:2] >= (3, 7):
    Final = typing.Final
# 3.7
else:
    class _FinalForm(typing._SpecialForm, _root=True):

        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            item = typing._type_check(parameters,
                                      f'{self._name} accepts only a single type.')
            return typing._GenericAlias(self, (item,))

    Final = _FinalForm('Final',
                       doc="""A special typing construct to indicate that a name
                       cannot be re-assigned or overridden in a subclass.
                       For example:

                           MAX_SIZE: Final = 9000
                           MAX_SIZE += 1  # Error reported by type checker

                           class Connection:
                               TIMEOUT: Final[int] = 10
                           class FastConnector(Connection):
                               TIMEOUT = 1  # Error reported by type checker

                       There is no runtime checking of these properties.""")

if sys.version_info >= (3, 11):
    final = typing.final
else:
    # @final exists in 3.8+, but we backport it for all versions
    # before 3.11 to keep support for the __final__ attribute.
    # See https://bugs.python.org/issue46342
    def final(f):
        """This decorator can be used to indicate to type checkers that
        the decorated method cannot be overridden, and decorated class
        cannot be subclassed. For example:

            class Base:
                @final
                def done(self) -> None:
                    ...
            class Sub(Base):
                def done(self) -> None:  # Error reported by type checker
                    ...
            @final
            class Leaf:
                ...
            class Other(Leaf):  # Error reported by type checker
                ...

        There is no runtime checking of these properties. The decorator
        sets the ``__final__`` attribute to ``True`` on the decorated object
        to allow runtime introspection.
        """
        try:
            f.__final__ = True
        except (AttributeError, TypeError):
            # Skip the attribute silently if it is not writable.
            # AttributeError happens if the object has __slots__ or a
            # read-only property, TypeError if it's a builtin class.
            pass
        return f


def IntVar(name):
    return typing.TypeVar(name)


# 3.8+:
if hasattr(typing, 'Literal'):
    Literal = typing.Literal
# 3.7:
else:
    class _LiteralForm(typing._SpecialForm, _root=True):

        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            return typing._GenericAlias(self, parameters)

    Literal = _LiteralForm('Literal',
                           doc="""A type that can be used to indicate to type checkers
                           that the corresponding value has a value literally equivalent
                           to the provided parameter. For example:

                               var: Literal[4] = 4

                           The type checker understands that 'var' is literally equal to
                           the value 4 and no other value.

                           Literal[...] cannot be subclassed. There is no runtime
                           checking verifying that the parameter is actually a value
                           instead of a type.""")


_overload_dummy = typing._overload_dummy  # noqa


if hasattr(typing, "get_overloads"):  # 3.11+
    overload = typing.overload
    get_overloads = typing.get_overloads
    clear_overloads = typing.clear_overloads
else:
    # {module: {qualname: {firstlineno: func}}}
    _overload_registry = collections.defaultdict(
        functools.partial(collections.defaultdict, dict)
    )

    def overload(func):
        """Decorator for overloaded functions/methods.

        In a stub file, place two or more stub definitions for the same
        function in a row, each decorated with @overload.  For example:

        @overload
        def utf8(value: None) -> None: ...
        @overload
        def utf8(value: bytes) -> bytes: ...
        @overload
        def utf8(value: str) -> bytes: ...

        In a non-stub file (i.e. a regular .py file), do the same but
        follow it with an implementation.  The implementation should *not*
        be decorated with @overload.  For example:

        @overload
        def utf8(value: None) -> None: ...
        @overload
        def utf8(value: bytes) -> bytes: ...
        @overload
        def utf8(value: str) -> bytes: ...
        def utf8(value):
            # implementation goes here

        The overloads for a function can be retrieved at runtime using the
        get_overloads() function.
        """
        # classmethod and staticmethod
        f = getattr(func, "__func__", func)
        try:
            _overload_registry[f.__module__][f.__qualname__][
                f.__code__.co_firstlineno
            ] = func
        except AttributeError:
            # Not a normal function; ignore.
            pass
        return _overload_dummy

    def get_overloads(func):
        """Return all defined overloads for *func* as a sequence."""
        # classmethod and staticmethod
        f = getattr(func, "__func__", func)
        if f.__module__ not in _overload_registry:
            return []
        mod_dict = _overload_registry[f.__module__]
        if f.__qualname__ not in mod_dict:
            return []
        return list(mod_dict[f.__qualname__].values())

    def clear_overloads():
        """Clear all overloads in the registry."""
        _overload_registry.clear()


# This is not a real generic class.  Don't use outside annotations.
Type = typing.Type

# Various ABCs mimicking those in collections.abc.
# A few are simply re-exported for completeness.


Awaitable = typing.Awaitable
Coroutine = typing.Coroutine
AsyncIterable = typing.AsyncIterable
AsyncIterator = typing.AsyncIterator
Deque = typing.Deque
ContextManager = typing.ContextManager
AsyncContextManager = typing.AsyncContextManager
DefaultDict = typing.DefaultDict

# 3.7.2+
if hasattr(typing, 'OrderedDict'):
    OrderedDict = typing.OrderedDict
# 3.7.0-3.7.2
else:
    OrderedDict = typing._alias(collections.OrderedDict, (KT, VT))

Counter = typing.Counter
ChainMap = typing.ChainMap
AsyncGenerator = typing.AsyncGenerator
NewType = typing.NewType
Text = typing.Text
TYPE_CHECKING = typing.TYPE_CHECKING


_PROTO_WHITELIST = ['Callable', 'Awaitable',
                    'Iterable', 'Iterator', 'AsyncIterable', 'AsyncIterator',
                    'Hashable', 'Sized', 'Container', 'Collection', 'Reversible',
                    'ContextManager', 'AsyncContextManager']


def _get_protocol_attrs(cls):
    attrs = set()
    for base in cls.__mro__[:-1]:  # without object
        if base.__name__ in ('Protocol', 'Generic'):
            continue
        annotations = getattr(base, '__annotations__', {})
        for attr in list(base.__dict__.keys()) + list(annotations.keys()):
            if (not attr.startswith('_abc_') and attr not in (
                    '__abstractmethods__', '__annotations__', '__weakref__',
                    '_is_protocol', '_is_runtime_protocol', '__dict__',
                    '__args__', '__slots__',
                    '__next_in_mro__', '__parameters__', '__origin__',
                    '__orig_bases__', '__extra__', '__tree_hash__',
                    '__doc__', '__subclasshook__', '__init__', '__new__',
                    '__module__', '_MutableMapping__marker', '_gorg')):
                attrs.add(attr)
    return attrs


def _is_callable_members_only(cls):
    return all(callable(getattr(cls, attr, None)) for attr in _get_protocol_attrs(cls))


def _maybe_adjust_parameters(cls):
    """Helper function used in Protocol.__init_subclass__ and _TypedDictMeta.__new__.

    The contents of this function are very similar
    to logic found in typing.Generic.__init_subclass__
    on the CPython main branch.
    """
    tvars = []
    if '__orig_bases__' in cls.__dict__:
        tvars = typing._collect_type_vars(cls.__orig_bases__)
        # Look for Generic[T1, ..., Tn] or Protocol[T1, ..., Tn].
        # If found, tvars must be a subset of it.
        # If not found, tvars is it.
        # Also check for and reject plain Generic,
        # and reject multiple Generic[...] and/or Protocol[...].
        gvars = None
        for base in cls.__orig_bases__:
            if (isinstance(base, typing._GenericAlias) and
                    base.__origin__ in (typing.Generic, Protocol)):
                # for error messages
                the_base = base.__origin__.__name__
                if gvars is not None:
                    raise TypeError(
                        "Cannot inherit from Generic[...]"
                        " and/or Protocol[...] multiple types.")
                gvars = base.__parameters__
        if gvars is None:
            gvars = tvars
        else:
            tvarset = set(tvars)
            gvarset = set(gvars)
            if not tvarset <= gvarset:
                s_vars = ', '.join(str(t) for t in tvars if t not in gvarset)
                s_args = ', '.join(str(g) for g in gvars)
                raise TypeError(f"Some type variables ({s_vars}) are"
                                f" not listed in {the_base}[{s_args}]")
            tvars = gvars
    cls.__parameters__ = tuple(tvars)


# 3.8+
if hasattr(typing, 'Protocol'):
    Protocol = typing.Protocol
# 3.7
else:

    def _no_init(self, *args, **kwargs):
        if type(self)._is_protocol:
            raise TypeError('Protocols cannot be instantiated')

    class _ProtocolMeta(abc.ABCMeta):  # noqa: B024
        # This metaclass is a bit unfortunate and exists only because of the lack
        # of __instancehook__.
        def __instancecheck__(cls, instance):
            # We need this method for situations where attributes are
            # assigned in __init__.
            if ((not getattr(cls, '_is_protocol', False) or
                 _is_callable_members_only(cls)) and
                    issubclass(instance.__class__, cls)):
                return True
            if cls._is_protocol:
                if all(hasattr(instance, attr) and
                       (not callable(getattr(cls, attr, None)) or
                        getattr(instance, attr) is not None)
                       for attr in _get_protocol_attrs(cls)):
                    return True
            return super().__instancecheck__(instance)

    class Protocol(metaclass=_ProtocolMeta):
        # There is quite a lot of overlapping code with typing.Generic.
        # Unfortunately it is hard to avoid this while these live in two different
        # modules. The duplicated code will be removed when Protocol is moved to typing.
        """Base class for protocol classes. Protocol classes are defined as::

            class Proto(Protocol):
                def meth(self) -> int:
                    ...

        Such classes are primarily used with static type checkers that recognize
        structural subtyping (static duck-typing), for example::

            class C:
                def meth(self) -> int:
                    return 0

            def func(x: Proto) -> int:
                return x.meth()

            func(C())  # Passes static type check

        See PEP 544 for details. Protocol classes decorated with
        @typing_extensions.runtime act as simple-minded runtime protocol that checks
        only the presence of given attributes, ignoring their type signatures.

        Protocol classes can be generic, they are defined as::

            class GenProto(Protocol[T]):
                def meth(self) -> T:
                    ...
        """
        __slots__ = ()
        _is_protocol = True

        def __new__(cls, *args, **kwds):
            if cls is Protocol:
                raise TypeError("Type Protocol cannot be instantiated; "
                                "it can only be used as a base class")
            return super().__new__(cls)

        @typing._tp_cache
        def __class_getitem__(cls, params):
            if not isinstance(params, tuple):
                params = (params,)
            if not params and cls is not typing.Tuple:
                raise TypeError(
                    f"Parameter list to {cls.__qualname__}[...] cannot be empty")
            msg = "Parameters to generic types must be types."
            params = tuple(typing._type_check(p, msg) for p in params)  # noqa
            if cls is Protocol:
                # Generic can only be subscripted with unique type variables.
                if not all(isinstance(p, typing.TypeVar) for p in params):
                    i = 0
                    while isinstance(params[i], typing.TypeVar):
                        i += 1
                    raise TypeError(
                        "Parameters to Protocol[...] must all be type variables."
                        f" Parameter {i + 1} is {params[i]}")
                if len(set(params)) != len(params):
                    raise TypeError(
                        "Parameters to Protocol[...] must all be unique")
            else:
                # Subscripting a regular Generic subclass.
                _check_generic(cls, params, len(cls.__parameters__))
            return typing._GenericAlias(cls, params)

        def __init_subclass__(cls, *args, **kwargs):
            if '__orig_bases__' in cls.__dict__:
                error = typing.Generic in cls.__orig_bases__
            else:
                error = typing.Generic in cls.__bases__
            if error:
                raise TypeError("Cannot inherit from plain Generic")
            _maybe_adjust_parameters(cls)

            # Determine if this is a protocol or a concrete subclass.
            if not cls.__dict__.get('_is_protocol', None):
                cls._is_protocol = any(b is Protocol for b in cls.__bases__)

            # Set (or override) the protocol subclass hook.
            def _proto_hook(other):
                if not cls.__dict__.get('_is_protocol', None):
                    return NotImplemented
                if not getattr(cls, '_is_runtime_protocol', False):
                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
                        return NotImplemented
                    raise TypeError("Instance and class checks can only be used with"
                                    " @runtime protocols")
                if not _is_callable_members_only(cls):
                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
                        return NotImplemented
                    raise TypeError("Protocols with non-method members"
                                    " don't support issubclass()")
                if not isinstance(other, type):
                    # Same error as for issubclass(1, int)
                    raise TypeError('issubclass() arg 1 must be a class')
                for attr in _get_protocol_attrs(cls):
                    for base in other.__mro__:
                        if attr in base.__dict__:
                            if base.__dict__[attr] is None:
                                return NotImplemented
                            break
                        annotations = getattr(base, '__annotations__', {})
                        if (isinstance(annotations, typing.Mapping) and
                                attr in annotations and
                                isinstance(other, _ProtocolMeta) and
                                other._is_protocol):
                            break
                    else:
                        return NotImplemented
                return True
            if '__subclasshook__' not in cls.__dict__:
                cls.__subclasshook__ = _proto_hook

            # We have nothing more to do for non-protocols.
            if not cls._is_protocol:
                return

            # Check consistency of bases.
            for base in cls.__bases__:
                if not (base in (object, typing.Generic) or
                        base.__module__ == 'collections.abc' and
                        base.__name__ in _PROTO_WHITELIST or
                        isinstance(base, _ProtocolMeta) and base._is_protocol):
                    raise TypeError('Protocols can only inherit from other'
                                    f' protocols, got {repr(base)}')
            cls.__init__ = _no_init


# 3.8+
if hasattr(typing, 'runtime_checkable'):
    runtime_checkable = typing.runtime_checkable
# 3.7
else:
    def runtime_checkable(cls):
        """Mark a protocol class as a runtime protocol, so that it
        can be used with isinstance() and issubclass(). Raise TypeError
        if applied to a non-protocol class.

        This allows a simple-minded structural check very similar to the
        one-offs in collections.abc such as Hashable.
        """
        if not isinstance(cls, _ProtocolMeta) or not cls._is_protocol:
            raise TypeError('@runtime_checkable can be only applied to protocol classes,'
                            f' got {cls!r}')
        cls._is_runtime_protocol = True
        return cls


# Exists for backwards compatibility.
runtime = runtime_checkable


# 3.8+
if hasattr(typing, 'SupportsIndex'):
    SupportsIndex = typing.SupportsIndex
# 3.7
else:
    @runtime_checkable
    class SupportsIndex(Protocol):
        __slots__ = ()

        @abc.abstractmethod
        def __index__(self) -> int:
            pass


if hasattr(typing, "Required"):
    # The standard library TypedDict in Python 3.8 does not store runtime information
    # about which (if any) keys are optional.  See https://bugs.python.org/issue38834
    # The standard library TypedDict in Python 3.9.0/1 does not honour the "total"
    # keyword with old-style TypedDict().  See https://bugs.python.org/issue42059
    # The standard library TypedDict below Python 3.11 does not store runtime
    # information about optional and required keys when using Required or NotRequired.
    # Generic TypedDicts are also impossible using typing.TypedDict on Python <3.11.
    TypedDict = typing.TypedDict
    _TypedDictMeta = typing._TypedDictMeta
    is_typeddict = typing.is_typeddict
else:
    def _check_fails(cls, other):
        try:
            if sys._getframe(1).f_globals['__name__'] not in ['abc',
                                                              'functools',
                                                              'typing']:
                # Typed dicts are only for static structural subtyping.
                raise TypeError('TypedDict does not support instance and class checks')
        except (AttributeError, ValueError):
            pass
        return False

    def _dict_new(*args, **kwargs):
        if not args:
            raise TypeError('TypedDict.__new__(): not enough arguments')
        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
        return dict(*args, **kwargs)

    _dict_new.__text_signature__ = '($cls, _typename, _fields=None, /, **kwargs)'

    def _typeddict_new(*args, total=True, **kwargs):
        if not args:
            raise TypeError('TypedDict.__new__(): not enough arguments')
        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
        if args:
            typename, args = args[0], args[1:]  # allow the "_typename" keyword be passed
        elif '_typename' in kwargs:
            typename = kwargs.pop('_typename')
            import warnings
            warnings.warn("Passing '_typename' as keyword argument is deprecated",
                          DeprecationWarning, stacklevel=2)
        else:
            raise TypeError("TypedDict.__new__() missing 1 required positional "
                            "argument: '_typename'")
        if args:
            try:
                fields, = args  # allow the "_fields" keyword be passed
            except ValueError:
                raise TypeError('TypedDict.__new__() takes from 2 to 3 '
                                f'positional arguments but {len(args) + 2} '
                                'were given')
        elif '_fields' in kwargs and len(kwargs) == 1:
            fields = kwargs.pop('_fields')
            import warnings
            warnings.warn("Passing '_fields' as keyword argument is deprecated",
                          DeprecationWarning, stacklevel=2)
        else:
            fields = None

        if fields is None:
            fields = kwargs
        elif kwargs:
            raise TypeError("TypedDict takes either a dict or keyword arguments,"
                            " but not both")

        ns = {'__annotations__': dict(fields)}
        try:
            # Setting correct module is necessary to make typed dict classes pickleable.
            ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
        except (AttributeError, ValueError):
            pass

        return _TypedDictMeta(typename, (), ns, total=total)

    _typeddict_new.__text_signature__ = ('($cls, _typename, _fields=None,'
                                         ' /, *, total=True, **kwargs)')

    class _TypedDictMeta(type):
        def __init__(cls, name, bases, ns, total=True):
            super().__init__(name, bases, ns)

        def __new__(cls, name, bases, ns, total=True):
            # Create new typed dict class object.
            # This method is called directly when TypedDict is subclassed,
            # or via _typeddict_new when TypedDict is instantiated. This way
            # TypedDict supports all three syntaxes described in its docstring.
            # Subclasses and instances of TypedDict return actual dictionaries
            # via _dict_new.
            ns['__new__'] = _typeddict_new if name == 'TypedDict' else _dict_new
            # Don't insert typing.Generic into __bases__ here,
            # or Generic.__init_subclass__ will raise TypeError
            # in the super().__new__() call.
            # Instead, monkey-patch __bases__ onto the class after it's been created.
            tp_dict = super().__new__(cls, name, (dict,), ns)

            if any(issubclass(base, typing.Generic) for base in bases):
                tp_dict.__bases__ = (typing.Generic, dict)
                _maybe_adjust_parameters(tp_dict)

            annotations = {}
            own_annotations = ns.get('__annotations__', {})
            msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
            own_annotations = {
                n: typing._type_check(tp, msg) for n, tp in own_annotations.items()
            }
            required_keys = set()
            optional_keys = set()

            for base in bases:
                annotations.update(base.__dict__.get('__annotations__', {}))
                required_keys.update(base.__dict__.get('__required_keys__', ()))
                optional_keys.update(base.__dict__.get('__optional_keys__', ()))

            annotations.update(own_annotations)
            for annotation_key, annotation_type in own_annotations.items():
                annotation_origin = get_origin(annotation_type)
                if annotation_origin is Annotated:
                    annotation_args = get_args(annotation_type)
                    if annotation_args:
                        annotation_type = annotation_args[0]
                        annotation_origin = get_origin(annotation_type)

                if annotation_origin is Required:
                    required_keys.add(annotation_key)
                elif annotation_origin is NotRequired:
                    optional_keys.add(annotation_key)
                elif total:
                    required_keys.add(annotation_key)
                else:
                    optional_keys.add(annotation_key)

            tp_dict.__annotations__ = annotations
            tp_dict.__required_keys__ = frozenset(required_keys)
            tp_dict.__optional_keys__ = frozenset(optional_keys)
            if not hasattr(tp_dict, '__total__'):
                tp_dict.__total__ = total
            return tp_dict

        __instancecheck__ = __subclasscheck__ = _check_fails

    TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
    TypedDict.__module__ = __name__
    TypedDict.__doc__ = \
        """A simple typed name space. At runtime it is equivalent to a plain dict.

        TypedDict creates a dictionary type that expects all of its
        instances to have a certain set of keys, with each key
        associated with a value of a consistent type. This expectation
        is not checked at runtime but is only enforced by type checkers.
        Usage::

            class Point2D(TypedDict):
                x: int
                y: int
                label: str

            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check

            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')

        The type info can be accessed via the Point2D.__annotations__ dict, and
        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
        TypedDict supports two additional equivalent forms::

            Point2D = TypedDict('Point2D', x=int, y=int, label=str)
            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})

        The class syntax is only supported in Python 3.6+, while two other
        syntax forms work for Python 2.7 and 3.2+
        """

    if hasattr(typing, "_TypedDictMeta"):
        _TYPEDDICT_TYPES = (typing._TypedDictMeta, _TypedDictMeta)
    else:
        _TYPEDDICT_TYPES = (_TypedDictMeta,)

    def is_typeddict(tp):
        """Check if an annotation is a TypedDict class

        For example::
            class Film(TypedDict):
                title: str
                year: int

            is_typeddict(Film)  # => True
            is_typeddict(Union[list, str])  # => False
        """
        return isinstance(tp, tuple(_TYPEDDICT_TYPES))


if hasattr(typing, "assert_type"):
    assert_type = typing.assert_type

else:
    def assert_type(__val, __typ):
        """Assert (to the type checker) that the value is of the given type.

        When the type checker encounters a call to assert_type(), it
        emits an error if the value is not of the specified type::

            def greet(name: str) -> None:
                assert_type(name, str)  # ok
                assert_type(name, int)  # type checker error

        At runtime this returns the first argument unchanged and otherwise
        does nothing.
        """
        return __val


if hasattr(typing, "Required"):
    get_type_hints = typing.get_type_hints
else:
    import functools
    import types

    # replaces _strip_annotations()
    def _strip_extras(t):
        """Strips Annotated, Required and NotRequired from a given type."""
        if isinstance(t, _AnnotatedAlias):
            return _strip_extras(t.__origin__)
        if hasattr(t, "__origin__") and t.__origin__ in (Required, NotRequired):
            return _strip_extras(t.__args__[0])
        if isinstance(t, typing._GenericAlias):
            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
            if stripped_args == t.__args__:
                return t
            return t.copy_with(stripped_args)
        if hasattr(types, "GenericAlias") and isinstance(t, types.GenericAlias):
            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
            if stripped_args == t.__args__:
                return t
            return types.GenericAlias(t.__origin__, stripped_args)
        if hasattr(types, "UnionType") and isinstance(t, types.UnionType):
            stripped_args = tuple(_strip_extras(a) for a in t.__args__)
            if stripped_args == t.__args__:
                return t
            return functools.reduce(operator.or_, stripped_args)

        return t

    def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
        """Return type hints for an object.

        This is often the same as obj.__annotations__, but it handles
        forward references encoded as string literals, adds Optional[t] if a
        default value equal to None is set and recursively replaces all
        'Annotated[T, ...]', 'Required[T]' or 'NotRequired[T]' with 'T'
        (unless 'include_extras=True').

        The argument may be a module, class, method, or function. The annotations
        are returned as a dictionary. For classes, annotations include also
        inherited members.

        TypeError is raised if the argument is not of a type that can contain
        annotations, and an empty dictionary is returned if no annotations are
        present.

        BEWARE -- the behavior of globalns and localns is counterintuitive
        (unless you are familiar with how eval() and exec() work).  The
        search order is locals first, then globals.

        - If no dict arguments are passed, an attempt is made to use the
          globals from obj (or the respective module's globals for classes),
          and these are also used as the locals.  If the object does not appear
          to have globals, an empty dictionary is used.

        - If one dict argument is passed, it is used for both globals and
          locals.

        - If two dict arguments are passed, they specify globals and
          locals, respectively.
        """
        if hasattr(typing, "Annotated"):
            hint = typing.get_type_hints(
                obj, globalns=globalns, localns=localns, include_extras=True
            )
        else:
            hint = typing.get_type_hints(obj, globalns=globalns, localns=localns)
        if include_extras:
            return hint
        return {k: _strip_extras(t) for k, t in hint.items()}


# Python 3.9+ has PEP 593 (Annotated)
if hasattr(typing, 'Annotated'):
    Annotated = typing.Annotated
    # Not exported and not a public API, but needed for get_origin() and get_args()
    # to work.
    _AnnotatedAlias = typing._AnnotatedAlias
# 3.7-3.8
else:
    class _AnnotatedAlias(typing._GenericAlias, _root=True):
        """Runtime representation of an annotated type.

        At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't'
        with extra annotations. The alias behaves like a normal typing alias,
        instantiating is the same as instantiating the underlying type, binding
        it to types is also the same.
        """
        def __init__(self, origin, metadata):
            if isinstance(origin, _AnnotatedAlias):
                metadata = origin.__metadata__ + metadata
                origin = origin.__origin__
            super().__init__(origin, origin)
            self.__metadata__ = metadata

        def copy_with(self, params):
            assert len(params) == 1
            new_type = params[0]
            return _AnnotatedAlias(new_type, self.__metadata__)

        def __repr__(self):
            return (f"typing_extensions.Annotated[{typing._type_repr(self.__origin__)}, "
                    f"{', '.join(repr(a) for a in self.__metadata__)}]")

        def __reduce__(self):
            return operator.getitem, (
                Annotated, (self.__origin__,) + self.__metadata__
            )

        def __eq__(self, other):
            if not isinstance(other, _AnnotatedAlias):
                return NotImplemented
            if self.__origin__ != other.__origin__:
                return False
            return self.__metadata__ == other.__metadata__

        def __hash__(self):
            return hash((self.__origin__, self.__metadata__))

    class Annotated:
        """Add context specific metadata to a type.

        Example: Annotated[int, runtime_check.Unsigned] indicates to the
        hypothetical runtime_check module that this type is an unsigned int.
        Every other consumer of this type can ignore this metadata and treat
        this type as int.

        The first argument to Annotated must be a valid type (and will be in
        the __origin__ field), the remaining arguments are kept as a tuple in
        the __extra__ field.

        Details:

        - It's an error to call `Annotated` with less than two arguments.
        - Nested Annotated are flattened::

            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]

        - Instantiating an annotated type is equivalent to instantiating the
        underlying type::

            Annotated[C, Ann1](5) == C(5)

        - Annotated can be used as a generic type alias::

            Optimized = Annotated[T, runtime.Optimize()]
            Optimized[int] == Annotated[int, runtime.Optimize()]

            OptimizedList = Annotated[List[T], runtime.Optimize()]
            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
        """

        __slots__ = ()

        def __new__(cls, *args, **kwargs):
            raise TypeError("Type Annotated cannot be instantiated.")

        @typing._tp_cache
        def __class_getitem__(cls, params):
            if not isinstance(params, tuple) or len(params) < 2:
                raise TypeError("Annotated[...] should be used "
                                "with at least two arguments (a type and an "
                                "annotation).")
            allowed_special_forms = (ClassVar, Final)
            if get_origin(params[0]) in allowed_special_forms:
                origin = params[0]
            else:
                msg = "Annotated[t, ...]: t must be a type."
                origin = typing._type_check(params[0], msg)
            metadata = tuple(params[1:])
            return _AnnotatedAlias(origin, metadata)

        def __init_subclass__(cls, *args, **kwargs):
            raise TypeError(
                f"Cannot subclass {cls.__module__}.Annotated"
            )

# Python 3.8 has get_origin() and get_args() but those implementations aren't
# Annotated-aware, so we can't use those. Python 3.9's versions don't support
# ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do.
if sys.version_info[:2] >= (3, 10):
    get_origin = typing.get_origin
    get_args = typing.get_args
# 3.7-3.9
else:
    try:
        # 3.9+
        from typing import _BaseGenericAlias
    except ImportError:
        _BaseGenericAlias = typing._GenericAlias
    try:
        # 3.9+
        from typing import GenericAlias as _typing_GenericAlias
    except ImportError:
        _typing_GenericAlias = typing._GenericAlias

    def get_origin(tp):
        """Get the unsubscripted version of a type.

        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
        and Annotated. Return None for unsupported types. Examples::

            get_origin(Literal[42]) is Literal
            get_origin(int) is None
            get_origin(ClassVar[int]) is ClassVar
            get_origin(Generic) is Generic
            get_origin(Generic[T]) is Generic
            get_origin(Union[T, int]) is Union
            get_origin(List[Tuple[T, T]][int]) == list
            get_origin(P.args) is P
        """
        if isinstance(tp, _AnnotatedAlias):
            return Annotated
        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias, _BaseGenericAlias,
                           ParamSpecArgs, ParamSpecKwargs)):
            return tp.__origin__
        if tp is typing.Generic:
            return typing.Generic
        return None

    def get_args(tp):
        """Get type arguments with all substitutions performed.

        For unions, basic simplifications used by Union constructor are performed.
        Examples::
            get_args(Dict[str, int]) == (str, int)
            get_args(int) == ()
            get_args(Union[int, Union[T, int], str][int]) == (int, str)
            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
            get_args(Callable[[], T][int]) == ([], int)
        """
        if isinstance(tp, _AnnotatedAlias):
            return (tp.__origin__,) + tp.__metadata__
        if isinstance(tp, (typing._GenericAlias, _typing_GenericAlias)):
            if getattr(tp, "_special", False):
                return ()
            res = tp.__args__
            if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis:
                res = (list(res[:-1]), res[-1])
            return res
        return ()


# 3.10+
if hasattr(typing, 'TypeAlias'):
    TypeAlias = typing.TypeAlias
# 3.9
elif sys.version_info[:2] >= (3, 9):
    class _TypeAliasForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    @_TypeAliasForm
    def TypeAlias(self, parameters):
        """Special marker indicating that an assignment should
        be recognized as a proper type alias definition by type
        checkers.

        For example::

            Predicate: TypeAlias = Callable[..., bool]

        It's invalid when used anywhere except as in the example above.
        """
        raise TypeError(f"{self} is not subscriptable")
# 3.7-3.8
else:
    class _TypeAliasForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    TypeAlias = _TypeAliasForm('TypeAlias',
                               doc="""Special marker indicating that an assignment should
                               be recognized as a proper type alias definition by type
                               checkers.

                               For example::

                                   Predicate: TypeAlias = Callable[..., bool]

                               It's invalid when used anywhere except as in the example
                               above.""")


class _DefaultMixin:
    """Mixin for TypeVarLike defaults."""

    __slots__ = ()

    def __init__(self, default):
        if isinstance(default, (tuple, list)):
            self.__default__ = tuple((typing._type_check(d, "Default must be a type")
                                      for d in default))
        elif default:
            self.__default__ = typing._type_check(default, "Default must be a type")
        else:
            self.__default__ = None


# Add default and infer_variance parameters from PEP 696 and 695
class TypeVar(typing.TypeVar, _DefaultMixin, _root=True):
    """Type variable."""

    __module__ = 'typing'

    def __init__(self, name, *constraints, bound=None,
                 covariant=False, contravariant=False,
                 default=None, infer_variance=False):
        super().__init__(name, *constraints, bound=bound, covariant=covariant,
                         contravariant=contravariant)
        _DefaultMixin.__init__(self, default)
        self.__infer_variance__ = infer_variance

        # for pickling:
        try:
            def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
        except (AttributeError, ValueError):
            def_mod = None
        if def_mod != 'typing_extensions':
            self.__module__ = def_mod


# Python 3.10+ has PEP 612
if hasattr(typing, 'ParamSpecArgs'):
    ParamSpecArgs = typing.ParamSpecArgs
    ParamSpecKwargs = typing.ParamSpecKwargs
# 3.7-3.9
else:
    class _Immutable:
        """Mixin to indicate that object should not be copied."""
        __slots__ = ()

        def __copy__(self):
            return self

        def __deepcopy__(self, memo):
            return self

    class ParamSpecArgs(_Immutable):
        """The args for a ParamSpec object.

        Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.

        ParamSpecArgs objects have a reference back to their ParamSpec:

        P.args.__origin__ is P

        This type is meant for runtime introspection and has no special meaning to
        static type checkers.
        """
        def __init__(self, origin):
            self.__origin__ = origin

        def __repr__(self):
            return f"{self.__origin__.__name__}.args"

        def __eq__(self, other):
            if not isinstance(other, ParamSpecArgs):
                return NotImplemented
            return self.__origin__ == other.__origin__

    class ParamSpecKwargs(_Immutable):
        """The kwargs for a ParamSpec object.

        Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.

        ParamSpecKwargs objects have a reference back to their ParamSpec:

        P.kwargs.__origin__ is P

        This type is meant for runtime introspection and has no special meaning to
        static type checkers.
        """
        def __init__(self, origin):
            self.__origin__ = origin

        def __repr__(self):
            return f"{self.__origin__.__name__}.kwargs"

        def __eq__(self, other):
            if not isinstance(other, ParamSpecKwargs):
                return NotImplemented
            return self.__origin__ == other.__origin__

# 3.10+
if hasattr(typing, 'ParamSpec'):

    # Add default Parameter - PEP 696
    class ParamSpec(typing.ParamSpec, _DefaultMixin, _root=True):
        """Parameter specification variable."""

        __module__ = 'typing'

        def __init__(self, name, *, bound=None, covariant=False, contravariant=False,
                     default=None):
            super().__init__(name, bound=bound, covariant=covariant,
                             contravariant=contravariant)
            _DefaultMixin.__init__(self, default)

            # for pickling:
            try:
                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
            except (AttributeError, ValueError):
                def_mod = None
            if def_mod != 'typing_extensions':
                self.__module__ = def_mod

# 3.7-3.9
else:

    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
    class ParamSpec(list, _DefaultMixin):
        """Parameter specification variable.

        Usage::

           P = ParamSpec('P')

        Parameter specification variables exist primarily for the benefit of static
        type checkers.  They are used to forward the parameter types of one
        callable to another callable, a pattern commonly found in higher order
        functions and decorators.  They are only valid when used in ``Concatenate``,
        or s the first argument to ``Callable``. In Python 3.10 and higher,
        they are also supported in user-defined Generics at runtime.
        See class Generic for more information on generic types.  An
        example for annotating a decorator::

           T = TypeVar('T')
           P = ParamSpec('P')

           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
               '''A type-safe decorator to add logging to a function.'''
               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
                   logging.info(f'{f.__name__} was called')
                   return f(*args, **kwargs)
               return inner

           @add_logging
           def add_two(x: float, y: float) -> float:
               '''Add two numbers together.'''
               return x + y

        Parameter specification variables defined with covariant=True or
        contravariant=True can be used to declare covariant or contravariant
        generic types.  These keyword arguments are valid, but their actual semantics
        are yet to be decided.  See PEP 612 for details.

        Parameter specification variables can be introspected. e.g.:

           P.__name__ == 'T'
           P.__bound__ == None
           P.__covariant__ == False
           P.__contravariant__ == False

        Note that only parameter specification variables defined in global scope can
        be pickled.
        """

        # Trick Generic __parameters__.
        __class__ = typing.TypeVar

        @property
        def args(self):
            return ParamSpecArgs(self)

        @property
        def kwargs(self):
            return ParamSpecKwargs(self)

        def __init__(self, name, *, bound=None, covariant=False, contravariant=False,
                     default=None):
            super().__init__([self])
            self.__name__ = name
            self.__covariant__ = bool(covariant)
            self.__contravariant__ = bool(contravariant)
            if bound:
                self.__bound__ = typing._type_check(bound, 'Bound must be a type.')
            else:
                self.__bound__ = None
            _DefaultMixin.__init__(self, default)

            # for pickling:
            try:
                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
            except (AttributeError, ValueError):
                def_mod = None
            if def_mod != 'typing_extensions':
                self.__module__ = def_mod

        def __repr__(self):
            if self.__covariant__:
                prefix = '+'
            elif self.__contravariant__:
                prefix = '-'
            else:
                prefix = '~'
            return prefix + self.__name__

        def __hash__(self):
            return object.__hash__(self)

        def __eq__(self, other):
            return self is other

        def __reduce__(self):
            return self.__name__

        # Hack to get typing._type_check to pass.
        def __call__(self, *args, **kwargs):
            pass


# 3.7-3.9
if not hasattr(typing, 'Concatenate'):
    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
    class _ConcatenateGenericAlias(list):

        # Trick Generic into looking into this for __parameters__.
        __class__ = typing._GenericAlias

        # Flag in 3.8.
        _special = False

        def __init__(self, origin, args):
            super().__init__(args)
            self.__origin__ = origin
            self.__args__ = args

        def __repr__(self):
            _type_repr = typing._type_repr
            return (f'{_type_repr(self.__origin__)}'
                    f'[{", ".join(_type_repr(arg) for arg in self.__args__)}]')

        def __hash__(self):
            return hash((self.__origin__, self.__args__))

        # Hack to get typing._type_check to pass in Generic.
        def __call__(self, *args, **kwargs):
            pass

        @property
        def __parameters__(self):
            return tuple(
                tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec))
            )


# 3.7-3.9
@typing._tp_cache
def _concatenate_getitem(self, parameters):
    if parameters == ():
        raise TypeError("Cannot take a Concatenate of no types.")
    if not isinstance(parameters, tuple):
        parameters = (parameters,)
    if not isinstance(parameters[-1], ParamSpec):
        raise TypeError("The last parameter to Concatenate should be a "
                        "ParamSpec variable.")
    msg = "Concatenate[arg, ...]: each arg must be a type."
    parameters = tuple(typing._type_check(p, msg) for p in parameters)
    return _ConcatenateGenericAlias(self, parameters)


# 3.10+
if hasattr(typing, 'Concatenate'):
    Concatenate = typing.Concatenate
    _ConcatenateGenericAlias = typing._ConcatenateGenericAlias # noqa
# 3.9
elif sys.version_info[:2] >= (3, 9):
    @_TypeAliasForm
    def Concatenate(self, parameters):
        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
        higher order function which adds, removes or transforms parameters of a
        callable.

        For example::

           Callable[Concatenate[int, P], int]

        See PEP 612 for detailed information.
        """
        return _concatenate_getitem(self, parameters)
# 3.7-8
else:
    class _ConcatenateForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            return _concatenate_getitem(self, parameters)

    Concatenate = _ConcatenateForm(
        'Concatenate',
        doc="""Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
        higher order function which adds, removes or transforms parameters of a
        callable.

        For example::

           Callable[Concatenate[int, P], int]

        See PEP 612 for detailed information.
        """)

# 3.10+
if hasattr(typing, 'TypeGuard'):
    TypeGuard = typing.TypeGuard
# 3.9
elif sys.version_info[:2] >= (3, 9):
    class _TypeGuardForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    @_TypeGuardForm
    def TypeGuard(self, parameters):
        """Special typing form used to annotate the return type of a user-defined
        type guard function.  ``TypeGuard`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.

        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".

        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
        return type to alert static type checkers to this intention.

        Using  ``-> TypeGuard`` tells the static type checker that for a given
        function:

        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the type inside ``TypeGuard``.

        For example::

            def is_str(val: Union[str, float]):
                # "isinstance" type guard
                if isinstance(val, str):
                    # Type of ``val`` is narrowed to ``str``
                    ...
                else:
                    # Else, type of ``val`` is narrowed to ``float``.
                    ...

        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
        form of ``TypeA`` (it can even be a wider form) and this may lead to
        type-unsafe results.  The main reason is to allow for things like
        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
        a subtype of the former, since ``List`` is invariant.  The responsibility of
        writing type-safe type guards is left to the user.

        ``TypeGuard`` also works with type variables.  For more information, see
        PEP 647 (User-Defined Type Guards).
        """
        item = typing._type_check(parameters, f'{self} accepts only a single type.')
        return typing._GenericAlias(self, (item,))
# 3.7-3.8
else:
    class _TypeGuardForm(typing._SpecialForm, _root=True):

        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            item = typing._type_check(parameters,
                                      f'{self._name} accepts only a single type')
            return typing._GenericAlias(self, (item,))

    TypeGuard = _TypeGuardForm(
        'TypeGuard',
        doc="""Special typing form used to annotate the return type of a user-defined
        type guard function.  ``TypeGuard`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.

        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".

        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
        return type to alert static type checkers to this intention.

        Using  ``-> TypeGuard`` tells the static type checker that for a given
        function:

        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the type inside ``TypeGuard``.

        For example::

            def is_str(val: Union[str, float]):
                # "isinstance" type guard
                if isinstance(val, str):
                    # Type of ``val`` is narrowed to ``str``
                    ...
                else:
                    # Else, type of ``val`` is narrowed to ``float``.
                    ...

        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
        form of ``TypeA`` (it can even be a wider form) and this may lead to
        type-unsafe results.  The main reason is to allow for things like
        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
        a subtype of the former, since ``List`` is invariant.  The responsibility of
        writing type-safe type guards is left to the user.

        ``TypeGuard`` also works with type variables.  For more information, see
        PEP 647 (User-Defined Type Guards).
        """)


# Vendored from cpython typing._SpecialFrom
class _SpecialForm(typing._Final, _root=True):
    __slots__ = ('_name', '__doc__', '_getitem')

    def __init__(self, getitem):
        self._getitem = getitem
        self._name = getitem.__name__
        self.__doc__ = getitem.__doc__

    def __getattr__(self, item):
        if item in {'__name__', '__qualname__'}:
            return self._name

        raise AttributeError(item)

    def __mro_entries__(self, bases):
        raise TypeError(f"Cannot subclass {self!r}")

    def __repr__(self):
        return f'typing_extensions.{self._name}'

    def __reduce__(self):
        return self._name

    def __call__(self, *args, **kwds):
        raise TypeError(f"Cannot instantiate {self!r}")

    def __or__(self, other):
        return typing.Union[self, other]

    def __ror__(self, other):
        return typing.Union[other, self]

    def __instancecheck__(self, obj):
        raise TypeError(f"{self} cannot be used with isinstance()")

    def __subclasscheck__(self, cls):
        raise TypeError(f"{self} cannot be used with issubclass()")

    @typing._tp_cache
    def __getitem__(self, parameters):
        return self._getitem(self, parameters)


if hasattr(typing, "LiteralString"):
    LiteralString = typing.LiteralString
else:
    @_SpecialForm
    def LiteralString(self, params):
        """Represents an arbitrary literal string.

        Example::

          from typing_extensions import LiteralString

          def query(sql: LiteralString) -> ...:
              ...

          query("SELECT * FROM table")  # ok
          query(f"SELECT * FROM {input()}")  # not ok

        See PEP 675 for details.

        """
        raise TypeError(f"{self} is not subscriptable")


if hasattr(typing, "Self"):
    Self = typing.Self
else:
    @_SpecialForm
    def Self(self, params):
        """Used to spell the type of "self" in classes.

        Example::

          from typing import Self

          class ReturnsSelf:
              def parse(self, data: bytes) -> Self:
                  ...
                  return self

        """

        raise TypeError(f"{self} is not subscriptable")


if hasattr(typing, "Never"):
    Never = typing.Never
else:
    @_SpecialForm
    def Never(self, params):
        """The bottom type, a type that has no members.

        This can be used to define a function that should never be
        called, or a function that never returns::

            from typing_extensions import Never

            def never_call_me(arg: Never) -> None:
                pass

            def int_or_str(arg: int | str) -> None:
                never_call_me(arg)  # type checker error
                match arg:
                    case int():
                        print("It's an int")
                    case str():
                        print("It's a str")
                    case _:
                        never_call_me(arg)  # ok, arg is of type Never

        """

        raise TypeError(f"{self} is not subscriptable")


if hasattr(typing, 'Required'):
    Required = typing.Required
    NotRequired = typing.NotRequired
elif sys.version_info[:2] >= (3, 9):
    class _ExtensionsSpecialForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    @_ExtensionsSpecialForm
    def Required(self, parameters):
        """A special typing construct to mark a key of a total=False TypedDict
        as required. For example:

            class Movie(TypedDict, total=False):
                title: Required[str]
                year: int

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )

        There is no runtime checking that a required key is actually provided
        when instantiating a related TypedDict.
        """
        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
        return typing._GenericAlias(self, (item,))

    @_ExtensionsSpecialForm
    def NotRequired(self, parameters):
        """A special typing construct to mark a key of a TypedDict as
        potentially missing. For example:

            class Movie(TypedDict):
                title: str
                year: NotRequired[int]

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
        """
        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
        return typing._GenericAlias(self, (item,))

else:
    class _RequiredForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            item = typing._type_check(parameters,
                                      f'{self._name} accepts only a single type.')
            return typing._GenericAlias(self, (item,))

    Required = _RequiredForm(
        'Required',
        doc="""A special typing construct to mark a key of a total=False TypedDict
        as required. For example:

            class Movie(TypedDict, total=False):
                title: Required[str]
                year: int

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )

        There is no runtime checking that a required key is actually provided
        when instantiating a related TypedDict.
        """)
    NotRequired = _RequiredForm(
        'NotRequired',
        doc="""A special typing construct to mark a key of a TypedDict as
        potentially missing. For example:

            class Movie(TypedDict):
                title: str
                year: NotRequired[int]

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
        """)


if hasattr(typing, "Unpack"):  # 3.11+
    Unpack = typing.Unpack
elif sys.version_info[:2] >= (3, 9):
    class _UnpackSpecialForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    class _UnpackAlias(typing._GenericAlias, _root=True):
        __class__ = typing.TypeVar

    @_UnpackSpecialForm
    def Unpack(self, parameters):
        """A special typing construct to unpack a variadic type. For example:

            Shape = TypeVarTuple('Shape')
            Batch = NewType('Batch', int)

            def add_batch_axis(
                x: Array[Unpack[Shape]]
            ) -> Array[Batch, Unpack[Shape]]: ...

        """
        item = typing._type_check(parameters, f'{self._name} accepts only a single type.')
        return _UnpackAlias(self, (item,))

    def _is_unpack(obj):
        return isinstance(obj, _UnpackAlias)

else:
    class _UnpackAlias(typing._GenericAlias, _root=True):
        __class__ = typing.TypeVar

    class _UnpackForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            item = typing._type_check(parameters,
                                      f'{self._name} accepts only a single type.')
            return _UnpackAlias(self, (item,))

    Unpack = _UnpackForm(
        'Unpack',
        doc="""A special typing construct to unpack a variadic type. For example:

            Shape = TypeVarTuple('Shape')
            Batch = NewType('Batch', int)

            def add_batch_axis(
                x: Array[Unpack[Shape]]
            ) -> Array[Batch, Unpack[Shape]]: ...

        """)

    def _is_unpack(obj):
        return isinstance(obj, _UnpackAlias)


if hasattr(typing, "TypeVarTuple"):  # 3.11+

    # Add default Parameter - PEP 696
    class TypeVarTuple(typing.TypeVarTuple, _DefaultMixin, _root=True):
        """Type variable tuple."""

        def __init__(self, name, *, default=None):
            super().__init__(name)
            _DefaultMixin.__init__(self, default)

            # for pickling:
            try:
                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
            except (AttributeError, ValueError):
                def_mod = None
            if def_mod != 'typing_extensions':
                self.__module__ = def_mod

else:
    class TypeVarTuple(_DefaultMixin):
        """Type variable tuple.

        Usage::

            Ts = TypeVarTuple('Ts')

        In the same way that a normal type variable is a stand-in for a single
        type such as ``int``, a type variable *tuple* is a stand-in for a *tuple*
        type such as ``Tuple[int, str]``.

        Type variable tuples can be used in ``Generic`` declarations.
        Consider the following example::

            class Array(Generic[*Ts]): ...

        The ``Ts`` type variable tuple here behaves like ``tuple[T1, T2]``,
        where ``T1`` and ``T2`` are type variables. To use these type variables
        as type parameters of ``Array``, we must *unpack* the type variable tuple using
        the star operator: ``*Ts``. The signature of ``Array`` then behaves
        as if we had simply written ``class Array(Generic[T1, T2]): ...``.
        In contrast to ``Generic[T1, T2]``, however, ``Generic[*Shape]`` allows
        us to parameterise the class with an *arbitrary* number of type parameters.

        Type variable tuples can be used anywhere a normal ``TypeVar`` can.
        This includes class definitions, as shown above, as well as function
        signatures and variable annotations::

            class Array(Generic[*Ts]):

                def __init__(self, shape: Tuple[*Ts]):
                    self._shape: Tuple[*Ts] = shape

                def get_shape(self) -> Tuple[*Ts]:
                    return self._shape

            shape = (Height(480), Width(640))
            x: Array[Height, Width] = Array(shape)
            y = abs(x)  # Inferred type is Array[Height, Width]
            z = x + x   #        ...    is Array[Height, Width]
            x.get_shape()  #     ...    is tuple[Height, Width]

        """

        # Trick Generic __parameters__.
        __class__ = typing.TypeVar

        def __iter__(self):
            yield self.__unpacked__

        def __init__(self, name, *, default=None):
            self.__name__ = name
            _DefaultMixin.__init__(self, default)

            # for pickling:
            try:
                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
            except (AttributeError, ValueError):
                def_mod = None
            if def_mod != 'typing_extensions':
                self.__module__ = def_mod

            self.__unpacked__ = Unpack[self]

        def __repr__(self):
            return self.__name__

        def __hash__(self):
            return object.__hash__(self)

        def __eq__(self, other):
            return self is other

        def __reduce__(self):
            return self.__name__

        def __init_subclass__(self, *args, **kwds):
            if '_root' not in kwds:
                raise TypeError("Cannot subclass special typing classes")


if hasattr(typing, "reveal_type"):
    reveal_type = typing.reveal_type
else:
    def reveal_type(__obj: T) -> T:
        """Reveal the inferred type of a variable.

        When a static type checker encounters a call to ``reveal_type()``,
        it will emit the inferred type of the argument::

            x: int = 1
            reveal_type(x)

        Running a static type checker (e.g., ``mypy``) on this example
        will produce output similar to 'Revealed type is "builtins.int"'.

        At runtime, the function prints the runtime type of the
        argument and returns it unchanged.

        """
        print(f"Runtime type is {type(__obj).__name__!r}", file=sys.stderr)
        return __obj


if hasattr(typing, "assert_never"):
    assert_never = typing.assert_never
else:
    def assert_never(__arg: Never) -> Never:
        """Assert to the type checker that a line of code is unreachable.

        Example::

            def int_or_str(arg: int | str) -> None:
                match arg:
                    case int():
                        print("It's an int")
                    case str():
                        print("It's a str")
                    case _:
                        assert_never(arg)

        If a type checker finds that a call to assert_never() is
        reachable, it will emit an error.

        At runtime, this throws an exception when called.

        """
        raise AssertionError("Expected code to be unreachable")


if hasattr(typing, 'dataclass_transform'):
    dataclass_transform = typing.dataclass_transform
else:
    def dataclass_transform(
        *,
        eq_default: bool = True,
        order_default: bool = False,
        kw_only_default: bool = False,
        field_specifiers: typing.Tuple[
            typing.Union[typing.Type[typing.Any], typing.Callable[..., typing.Any]],
            ...
        ] = (),
        **kwargs: typing.Any,
    ) -> typing.Callable[[T], T]:
        """Decorator that marks a function, class, or metaclass as providing
        dataclass-like behavior.

        Example:

            from typing_extensions import dataclass_transform

            _T = TypeVar("_T")

            # Used on a decorator function
            @dataclass_transform()
            def create_model(cls: type[_T]) -> type[_T]:
                ...
                return cls

            @create_model
            class CustomerModel:
                id: int
                name: str

            # Used on a base class
            @dataclass_transform()
            class ModelBase: ...

            class CustomerModel(ModelBase):
                id: int
                name: str

            # Used on a metaclass
            @dataclass_transform()
            class ModelMeta(type): ...

            class ModelBase(metaclass=ModelMeta): ...

            class CustomerModel(ModelBase):
                id: int
                name: str

        Each of the ``CustomerModel`` classes defined in this example will now
        behave similarly to a dataclass created with the ``@dataclasses.dataclass``
        decorator. For example, the type checker will synthesize an ``__init__``
        method.

        The arguments to this decorator can be used to customize this behavior:
        - ``eq_default`` indicates whether the ``eq`` parameter is assumed to be
          True or False if it is omitted by the caller.
        - ``order_default`` indicates whether the ``order`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``kw_only_default`` indicates whether the ``kw_only`` parameter is
          assumed to be True or False if it is omitted by the caller.
        - ``field_specifiers`` specifies a static list of supported classes
          or functions that describe fields, similar to ``dataclasses.field()``.

        At runtime, this decorator records its arguments in the
        ``__dataclass_transform__`` attribute on the decorated object.

        See PEP 681 for details.

        """
        def decorator(cls_or_fn):
            cls_or_fn.__dataclass_transform__ = {
                "eq_default": eq_default,
                "order_default": order_default,
                "kw_only_default": kw_only_default,
                "field_specifiers": field_specifiers,
                "kwargs": kwargs,
            }
            return cls_or_fn
        return decorator


if hasattr(typing, "override"):
    override = typing.override
else:
    _F = typing.TypeVar("_F", bound=typing.Callable[..., typing.Any])

    def override(__arg: _F) -> _F:
        """Indicate that a method is intended to override a method in a base class.

        Usage:

            class Base:
                def method(self) -> None: ...
                    pass

            class Child(Base):
                @override
                def method(self) -> None:
                    super().method()

        When this decorator is applied to a method, the type checker will
        validate that it overrides a method with the same name on a base class.
        This helps prevent bugs that may occur when a base class is changed
        without an equivalent change to a child class.

        See PEP 698 for details.

        """
        return __arg


# We have to do some monkey patching to deal with the dual nature of
# Unpack/TypeVarTuple:
# - We want Unpack to be a kind of TypeVar so it gets accepted in
#   Generic[Unpack[Ts]]
# - We want it to *not* be treated as a TypeVar for the purposes of
#   counting generic parameters, so that when we subscript a generic,
#   the runtime doesn't try to substitute the Unpack with the subscripted type.
if not hasattr(typing, "TypeVarTuple"):
    typing._collect_type_vars = _collect_type_vars
    typing._check_generic = _check_generic


# Backport typing.NamedTuple as it exists in Python 3.11.
# In 3.11, the ability to define generic `NamedTuple`s was supported.
# This was explicitly disallowed in 3.9-3.10, and only half-worked in <=3.8.
if sys.version_info >= (3, 11):
    NamedTuple = typing.NamedTuple
else:
    def _caller():
        try:
            return sys._getframe(2).f_globals.get('__name__', '__main__')
        except (AttributeError, ValueError):  # For platforms without _getframe()
            return None

    def _make_nmtuple(name, types, module, defaults=()):
        fields = [n for n, t in types]
        annotations = {n: typing._type_check(t, f"field {n} annotation must be a type")
                       for n, t in types}
        nm_tpl = collections.namedtuple(name, fields,
                                        defaults=defaults, module=module)
        nm_tpl.__annotations__ = nm_tpl.__new__.__annotations__ = annotations
        # The `_field_types` attribute was removed in 3.9;
        # in earlier versions, it is the same as the `__annotations__` attribute
        if sys.version_info < (3, 9):
            nm_tpl._field_types = annotations
        return nm_tpl

    _prohibited_namedtuple_fields = typing._prohibited
    _special_namedtuple_fields = frozenset({'__module__', '__name__', '__annotations__'})

    class _NamedTupleMeta(type):
        def __new__(cls, typename, bases, ns):
            assert _NamedTuple in bases
            for base in bases:
                if base is not _NamedTuple and base is not typing.Generic:
                    raise TypeError(
                        'can only inherit from a NamedTuple type and Generic')
            bases = tuple(tuple if base is _NamedTuple else base for base in bases)
            types = ns.get('__annotations__', {})
            default_names = []
            for field_name in types:
                if field_name in ns:
                    default_names.append(field_name)
                elif default_names:
                    raise TypeError(f"Non-default namedtuple field {field_name} "
                                    f"cannot follow default field"
                                    f"{'s' if len(default_names) > 1 else ''} "
                                    f"{', '.join(default_names)}")
            nm_tpl = _make_nmtuple(
                typename, types.items(),
                defaults=[ns[n] for n in default_names],
                module=ns['__module__']
            )
            nm_tpl.__bases__ = bases
            if typing.Generic in bases:
                class_getitem = typing.Generic.__class_getitem__.__func__
                nm_tpl.__class_getitem__ = classmethod(class_getitem)
            # update from user namespace without overriding special namedtuple attributes
            for key in ns:
                if key in _prohibited_namedtuple_fields:
                    raise AttributeError("Cannot overwrite NamedTuple attribute " + key)
                elif key not in _special_namedtuple_fields and key not in nm_tpl._fields:
                    setattr(nm_tpl, key, ns[key])
            if typing.Generic in bases:
                nm_tpl.__init_subclass__()
            return nm_tpl

    def NamedTuple(__typename, __fields=None, **kwargs):
        if __fields is None:
            __fields = kwargs.items()
        elif kwargs:
            raise TypeError("Either list of fields or keywords"
                            " can be provided to NamedTuple, not both")
        return _make_nmtuple(__typename, __fields, module=_caller())

    NamedTuple.__doc__ = typing.NamedTuple.__doc__
    _NamedTuple = type.__new__(_NamedTupleMeta, 'NamedTuple', (), {})

    # On 3.8+, alter the signature so that it matches typing.NamedTuple.
    # The signature of typing.NamedTuple on >=3.8 is invalid syntax in Python 3.7,
    # so just leave the signature as it is on 3.7.
    if sys.version_info >= (3, 8):
        NamedTuple.__text_signature__ = '(typename, fields=None, /, **kwargs)'

    def _namedtuple_mro_entries(bases):
        assert NamedTuple in bases
        return (_NamedTuple,)

    NamedTuple.__mro_entries__ = _namedtuple_mro_entries
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/vendored.txt0000644000175100001730000000040614467657412022330 0ustar00runnerdockerpackaging==23.1

platformdirs==2.6.2
# required for platformdirs on Python < 3.8
typing_extensions==4.4.0

jaraco.text==3.7.0
# required for jaraco.text on older Pythons
importlib_resources==5.10.2
# required for importlib_resources on older Pythons
zipp==3.7.0
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4995484
setuptools-68.1.2/pkg_resources/_vendor/zipp-3.7.0.dist-info/0000755000175100001730000000000014467657443023305 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/zipp-3.7.0.dist-info/top_level.txt0000644000175100001730000000000514467657412026026 0ustar00runnerdockerzipp
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/_vendor/zipp.py0000644000175100001730000002035114467657412021316 0ustar00runnerdockerimport io
import posixpath
import zipfile
import itertools
import contextlib
import sys
import pathlib

if sys.version_info < (3, 7):
    from collections import OrderedDict
else:
    OrderedDict = dict


__all__ = ['Path']


def _parents(path):
    """
    Given a path with elements separated by
    posixpath.sep, generate all parents of that path.

    >>> list(_parents('b/d'))
    ['b']
    >>> list(_parents('/b/d/'))
    ['/b']
    >>> list(_parents('b/d/f/'))
    ['b/d', 'b']
    >>> list(_parents('b'))
    []
    >>> list(_parents(''))
    []
    """
    return itertools.islice(_ancestry(path), 1, None)


def _ancestry(path):
    """
    Given a path with elements separated by
    posixpath.sep, generate all elements of that path

    >>> list(_ancestry('b/d'))
    ['b/d', 'b']
    >>> list(_ancestry('/b/d/'))
    ['/b/d', '/b']
    >>> list(_ancestry('b/d/f/'))
    ['b/d/f', 'b/d', 'b']
    >>> list(_ancestry('b'))
    ['b']
    >>> list(_ancestry(''))
    []
    """
    path = path.rstrip(posixpath.sep)
    while path and path != posixpath.sep:
        yield path
        path, tail = posixpath.split(path)


_dedupe = OrderedDict.fromkeys
"""Deduplicate an iterable in original order"""


def _difference(minuend, subtrahend):
    """
    Return items in minuend not in subtrahend, retaining order
    with O(1) lookup.
    """
    return itertools.filterfalse(set(subtrahend).__contains__, minuend)


class CompleteDirs(zipfile.ZipFile):
    """
    A ZipFile subclass that ensures that implied directories
    are always included in the namelist.
    """

    @staticmethod
    def _implied_dirs(names):
        parents = itertools.chain.from_iterable(map(_parents, names))
        as_dirs = (p + posixpath.sep for p in parents)
        return _dedupe(_difference(as_dirs, names))

    def namelist(self):
        names = super(CompleteDirs, self).namelist()
        return names + list(self._implied_dirs(names))

    def _name_set(self):
        return set(self.namelist())

    def resolve_dir(self, name):
        """
        If the name represents a directory, return that name
        as a directory (with the trailing slash).
        """
        names = self._name_set()
        dirname = name + '/'
        dir_match = name not in names and dirname in names
        return dirname if dir_match else name

    @classmethod
    def make(cls, source):
        """
        Given a source (filename or zipfile), return an
        appropriate CompleteDirs subclass.
        """
        if isinstance(source, CompleteDirs):
            return source

        if not isinstance(source, zipfile.ZipFile):
            return cls(_pathlib_compat(source))

        # Only allow for FastLookup when supplied zipfile is read-only
        if 'r' not in source.mode:
            cls = CompleteDirs

        source.__class__ = cls
        return source


class FastLookup(CompleteDirs):
    """
    ZipFile subclass to ensure implicit
    dirs exist and are resolved rapidly.
    """

    def namelist(self):
        with contextlib.suppress(AttributeError):
            return self.__names
        self.__names = super(FastLookup, self).namelist()
        return self.__names

    def _name_set(self):
        with contextlib.suppress(AttributeError):
            return self.__lookup
        self.__lookup = super(FastLookup, self)._name_set()
        return self.__lookup


def _pathlib_compat(path):
    """
    For path-like objects, convert to a filename for compatibility
    on Python 3.6.1 and earlier.
    """
    try:
        return path.__fspath__()
    except AttributeError:
        return str(path)


class Path:
    """
    A pathlib-compatible interface for zip files.

    Consider a zip file with this structure::

        .
        ├── a.txt
        └── b
            ├── c.txt
            └── d
                └── e.txt

    >>> data = io.BytesIO()
    >>> zf = zipfile.ZipFile(data, 'w')
    >>> zf.writestr('a.txt', 'content of a')
    >>> zf.writestr('b/c.txt', 'content of c')
    >>> zf.writestr('b/d/e.txt', 'content of e')
    >>> zf.filename = 'mem/abcde.zip'

    Path accepts the zipfile object itself or a filename

    >>> root = Path(zf)

    From there, several path operations are available.

    Directory iteration (including the zip file itself):

    >>> a, b = root.iterdir()
    >>> a
    Path('mem/abcde.zip', 'a.txt')
    >>> b
    Path('mem/abcde.zip', 'b/')

    name property:

    >>> b.name
    'b'

    join with divide operator:

    >>> c = b / 'c.txt'
    >>> c
    Path('mem/abcde.zip', 'b/c.txt')
    >>> c.name
    'c.txt'

    Read text:

    >>> c.read_text()
    'content of c'

    existence:

    >>> c.exists()
    True
    >>> (b / 'missing.txt').exists()
    False

    Coercion to string:

    >>> import os
    >>> str(c).replace(os.sep, posixpath.sep)
    'mem/abcde.zip/b/c.txt'

    At the root, ``name``, ``filename``, and ``parent``
    resolve to the zipfile. Note these attributes are not
    valid and will raise a ``ValueError`` if the zipfile
    has no filename.

    >>> root.name
    'abcde.zip'
    >>> str(root.filename).replace(os.sep, posixpath.sep)
    'mem/abcde.zip'
    >>> str(root.parent)
    'mem'
    """

    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"

    def __init__(self, root, at=""):
        """
        Construct a Path from a ZipFile or filename.

        Note: When the source is an existing ZipFile object,
        its type (__class__) will be mutated to a
        specialized type. If the caller wishes to retain the
        original type, the caller should either create a
        separate ZipFile object or pass a filename.
        """
        self.root = FastLookup.make(root)
        self.at = at

    def open(self, mode='r', *args, pwd=None, **kwargs):
        """
        Open this entry as text or binary following the semantics
        of ``pathlib.Path.open()`` by passing arguments through
        to io.TextIOWrapper().
        """
        if self.is_dir():
            raise IsADirectoryError(self)
        zip_mode = mode[0]
        if not self.exists() and zip_mode == 'r':
            raise FileNotFoundError(self)
        stream = self.root.open(self.at, zip_mode, pwd=pwd)
        if 'b' in mode:
            if args or kwargs:
                raise ValueError("encoding args invalid for binary operation")
            return stream
        return io.TextIOWrapper(stream, *args, **kwargs)

    @property
    def name(self):
        return pathlib.Path(self.at).name or self.filename.name

    @property
    def suffix(self):
        return pathlib.Path(self.at).suffix or self.filename.suffix

    @property
    def suffixes(self):
        return pathlib.Path(self.at).suffixes or self.filename.suffixes

    @property
    def stem(self):
        return pathlib.Path(self.at).stem or self.filename.stem

    @property
    def filename(self):
        return pathlib.Path(self.root.filename).joinpath(self.at)

    def read_text(self, *args, **kwargs):
        with self.open('r', *args, **kwargs) as strm:
            return strm.read()

    def read_bytes(self):
        with self.open('rb') as strm:
            return strm.read()

    def _is_child(self, path):
        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")

    def _next(self, at):
        return self.__class__(self.root, at)

    def is_dir(self):
        return not self.at or self.at.endswith("/")

    def is_file(self):
        return self.exists() and not self.is_dir()

    def exists(self):
        return self.at in self.root._name_set()

    def iterdir(self):
        if not self.is_dir():
            raise ValueError("Can't listdir a file")
        subs = map(self._next, self.root.namelist())
        return filter(self._is_child, subs)

    def __str__(self):
        return posixpath.join(self.root.filename, self.at)

    def __repr__(self):
        return self.__repr.format(self=self)

    def joinpath(self, *other):
        next = posixpath.join(self.at, *map(_pathlib_compat, other))
        return self._next(self.root.resolve_dir(next))

    __truediv__ = joinpath

    @property
    def parent(self):
        if not self.at:
            return self.filename.parent
        parent_at = posixpath.dirname(self.at.rstrip('/'))
        if parent_at:
            parent_at += '/'
        return self._next(parent_at)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/api_tests.txt0000644000175100001730000003046314467657412021067 0ustar00runnerdockerPluggable Distributions of Python Software
==========================================

Distributions
-------------

A "Distribution" is a collection of files that represent a "Release" of a
"Project" as of a particular point in time, denoted by a
"Version"::

    >>> import sys, pkg_resources
    >>> from pkg_resources import Distribution
    >>> Distribution(project_name="Foo", version="1.2")
    Foo 1.2

Distributions have a location, which can be a filename, URL, or really anything
else you care to use::

    >>> dist = Distribution(
    ...     location="http://example.com/something",
    ...     project_name="Bar", version="0.9"
    ... )

    >>> dist
    Bar 0.9 (http://example.com/something)


Distributions have various introspectable attributes::

    >>> dist.location
    'http://example.com/something'

    >>> dist.project_name
    'Bar'

    >>> dist.version
    '0.9'

    >>> dist.py_version == '{}.{}'.format(*sys.version_info)
    True

    >>> print(dist.platform)
    None

Including various computed attributes::

    >>> from pkg_resources import parse_version
    >>> dist.parsed_version == parse_version(dist.version)
    True

    >>> dist.key    # case-insensitive form of the project name
    'bar'

Distributions are compared (and hashed) by version first::

    >>> Distribution(version='1.0') == Distribution(version='1.0')
    True
    >>> Distribution(version='1.0') == Distribution(version='1.1')
    False
    >>> Distribution(version='1.0') <  Distribution(version='1.1')
    True

but also by project name (case-insensitive), platform, Python version,
location, etc.::

    >>> Distribution(project_name="Foo",version="1.0") == \
    ... Distribution(project_name="Foo",version="1.0")
    True

    >>> Distribution(project_name="Foo",version="1.0") == \
    ... Distribution(project_name="foo",version="1.0")
    True

    >>> Distribution(project_name="Foo",version="1.0") == \
    ... Distribution(project_name="Foo",version="1.1")
    False

    >>> Distribution(project_name="Foo",py_version="2.3",version="1.0") == \
    ... Distribution(project_name="Foo",py_version="2.4",version="1.0")
    False

    >>> Distribution(location="spam",version="1.0") == \
    ... Distribution(location="spam",version="1.0")
    True

    >>> Distribution(location="spam",version="1.0") == \
    ... Distribution(location="baz",version="1.0")
    False



Hash and compare distribution by prio/plat

Get version from metadata
provider capabilities
egg_name()
as_requirement()
from_location, from_filename (w/path normalization)

Releases may have zero or more "Requirements", which indicate
what releases of another project the release requires in order to
function.  A Requirement names the other project, expresses some criteria
as to what releases of that project are acceptable, and lists any "Extras"
that the requiring release may need from that project.  (An Extra is an
optional feature of a Release, that can only be used if its additional
Requirements are satisfied.)



The Working Set
---------------

A collection of active distributions is called a Working Set.  Note that a
Working Set can contain any importable distribution, not just pluggable ones.
For example, the Python standard library is an importable distribution that
will usually be part of the Working Set, even though it is not pluggable.
Similarly, when you are doing development work on a project, the files you are
editing are also a Distribution.  (And, with a little attention to the
directory names used,  and including some additional metadata, such a
"development distribution" can be made pluggable as well.)

    >>> from pkg_resources import WorkingSet

A working set's entries are the sys.path entries that correspond to the active
distributions.  By default, the working set's entries are the items on
``sys.path``::

    >>> ws = WorkingSet()
    >>> ws.entries == sys.path
    True

But you can also create an empty working set explicitly, and add distributions
to it::

    >>> ws = WorkingSet([])
    >>> ws.add(dist)
    >>> ws.entries
    ['http://example.com/something']
    >>> dist in ws
    True
    >>> Distribution('foo',version="") in ws
    False

And you can iterate over its distributions::

    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

Adding the same distribution more than once is a no-op::

    >>> ws.add(dist)
    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

For that matter, adding multiple distributions for the same project also does
nothing, because a working set can only hold one active distribution per
project -- the first one added to it::

    >>> ws.add(
    ...     Distribution(
    ...         'http://example.com/something', project_name="Bar",
    ...         version="7.2"
    ...     )
    ... )
    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

You can append a path entry to a working set using ``add_entry()``::

    >>> ws.entries
    ['http://example.com/something']
    >>> ws.add_entry(pkg_resources.__file__)
    >>> ws.entries
    ['http://example.com/something', '...pkg_resources...']

Multiple additions result in multiple entries, even if the entry is already in
the working set (because ``sys.path`` can contain the same entry more than
once)::

    >>> ws.add_entry(pkg_resources.__file__)
    >>> ws.entries
    ['...example.com...', '...pkg_resources...', '...pkg_resources...']

And you can specify the path entry a distribution was found under, using the
optional second parameter to ``add()``::

    >>> ws = WorkingSet([])
    >>> ws.add(dist,"foo")
    >>> ws.entries
    ['foo']

But even if a distribution is found under multiple path entries, it still only
shows up once when iterating the working set:

    >>> ws.add_entry(ws.entries[0])
    >>> list(ws)
    [Bar 0.9 (http://example.com/something)]

You can ask a WorkingSet to ``find()`` a distribution matching a requirement::

    >>> from pkg_resources import Requirement
    >>> print(ws.find(Requirement.parse("Foo==1.0")))   # no match, return None
    None

    >>> ws.find(Requirement.parse("Bar==0.9"))  # match, return distribution
    Bar 0.9 (http://example.com/something)

Note that asking for a conflicting version of a distribution already in a
working set triggers a ``pkg_resources.VersionConflict`` error:

    >>> try:
    ...     ws.find(Requirement.parse("Bar==1.0"))
    ... except pkg_resources.VersionConflict as exc:
    ...     print(str(exc))
    ... else:
    ...     raise AssertionError("VersionConflict was not raised")
    (Bar 0.9 (http://example.com/something), Requirement.parse('Bar==1.0'))

You can subscribe a callback function to receive notifications whenever a new
distribution is added to a working set.  The callback is immediately invoked
once for each existing distribution in the working set, and then is called
again for new distributions added thereafter::

    >>> def added(dist): print("Added %s" % dist)
    >>> ws.subscribe(added)
    Added Bar 0.9
    >>> foo12 = Distribution(project_name="Foo", version="1.2", location="f12")
    >>> ws.add(foo12)
    Added Foo 1.2

Note, however, that only the first distribution added for a given project name
will trigger a callback, even during the initial ``subscribe()`` callback::

    >>> foo14 = Distribution(project_name="Foo", version="1.4", location="f14")
    >>> ws.add(foo14)   # no callback, because Foo 1.2 is already active

    >>> ws = WorkingSet([])
    >>> ws.add(foo12)
    >>> ws.add(foo14)
    >>> ws.subscribe(added)
    Added Foo 1.2

And adding a callback more than once has no effect, either::

    >>> ws.subscribe(added)     # no callbacks

    # and no double-callbacks on subsequent additions, either
    >>> just_a_test = Distribution(project_name="JustATest", version="0.99")
    >>> ws.add(just_a_test)
    Added JustATest 0.99


Finding Plugins
---------------

``WorkingSet`` objects can be used to figure out what plugins in an
``Environment`` can be loaded without any resolution errors::

    >>> from pkg_resources import Environment

    >>> plugins = Environment([])   # normally, a list of plugin directories
    >>> plugins.add(foo12)
    >>> plugins.add(foo14)
    >>> plugins.add(just_a_test)

In the simplest case, we just get the newest version of each distribution in
the plugin environment::

    >>> ws = WorkingSet([])
    >>> ws.find_plugins(plugins)
    ([JustATest 0.99, Foo 1.4 (f14)], {})

But if there's a problem with a version conflict or missing requirements, the
method falls back to older versions, and the error info dict will contain an
exception instance for each unloadable plugin::

    >>> ws.add(foo12)   # this will conflict with Foo 1.4
    >>> ws.find_plugins(plugins)
    ([JustATest 0.99, Foo 1.2 (f12)], {Foo 1.4 (f14): VersionConflict(...)})

But if you disallow fallbacks, the failed plugin will be skipped instead of
trying older versions::

    >>> ws.find_plugins(plugins, fallback=False)
    ([JustATest 0.99], {Foo 1.4 (f14): VersionConflict(...)})



Platform Compatibility Rules
----------------------------

On the Mac, there are potential compatibility issues for modules compiled
on newer versions of macOS than what the user is running. Additionally,
macOS will soon have two platforms to contend with: Intel and PowerPC.

Basic equality works as on other platforms::

    >>> from pkg_resources import compatible_platforms as cp
    >>> reqd = 'macosx-10.4-ppc'
    >>> cp(reqd, reqd)
    True
    >>> cp("win32", reqd)
    False

Distributions made on other machine types are not compatible::

    >>> cp("macosx-10.4-i386", reqd)
    False

Distributions made on earlier versions of the OS are compatible, as
long as they are from the same top-level version. The patchlevel version
number does not matter::

    >>> cp("macosx-10.4-ppc", reqd)
    True
    >>> cp("macosx-10.3-ppc", reqd)
    True
    >>> cp("macosx-10.5-ppc", reqd)
    False
    >>> cp("macosx-9.5-ppc", reqd)
    False

Backwards compatibility for packages made via earlier versions of
setuptools is provided as well::

    >>> cp("darwin-8.2.0-Power_Macintosh", reqd)
    True
    >>> cp("darwin-7.2.0-Power_Macintosh", reqd)
    True
    >>> cp("darwin-8.2.0-Power_Macintosh", "macosx-10.3-ppc")
    False


Environment Markers
-------------------

    >>> from pkg_resources import invalid_marker as im, evaluate_marker as em
    >>> import os

    >>> print(im("sys_platform"))
    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
        sys_platform
                    ^

    >>> print(im("sys_platform=="))
    Expected a marker variable or quoted string
        sys_platform==
                      ^

    >>> print(im("sys_platform=='win32'"))
    False

    >>> print(im("sys=='x'"))
    Expected a marker variable or quoted string
        sys=='x'
        ^

    >>> print(im("(extra)"))
    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
        (extra)
              ^

    >>> print(im("(extra"))
    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
        (extra
              ^

    >>> print(im("os.open('foo')=='y'"))
    Expected a marker variable or quoted string
        os.open('foo')=='y'
        ^

    >>> print(im("'x'=='y' and os.open('foo')=='y'"))   # no short-circuit!
    Expected a marker variable or quoted string
        'x'=='y' and os.open('foo')=='y'
                     ^

    >>> print(im("'x'=='x' or os.open('foo')=='y'"))   # no short-circuit!
    Expected a marker variable or quoted string
        'x'=='x' or os.open('foo')=='y'
                    ^

    >>> print(im("r'x'=='x'"))
    Expected a marker variable or quoted string
        r'x'=='x'
        ^

    >>> print(im("'''x'''=='x'"))
    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
        '''x'''=='x'
          ^

    >>> print(im('"""x"""=="x"'))
    Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in
        """x"""=="x"
          ^

    >>> print(im(r"x\n=='x'"))
    Expected a marker variable or quoted string
        x\n=='x'
        ^

    >>> print(im("os.open=='y'"))
    Expected a marker variable or quoted string
        os.open=='y'
        ^

    >>> em("sys_platform=='win32'") == (sys.platform=='win32')
    True

    >>> em("python_version >= '2.7'")
    True

    >>> em("python_version > '2.6'")
    True

    >>> im("implementation_name=='cpython'")
    False

    >>> im("platform_python_implementation=='CPython'")
    False

    >>> im("implementation_version=='3.5.1'")
    False
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4995484
setuptools-68.1.2/pkg_resources/extern/0000755000175100001730000000000014467657443017636 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/extern/__init__.py0000644000175100001730000000461214467657412021746 0ustar00runnerdockerimport importlib.util
import sys


class VendorImporter:
    """
    A PEP 302 meta path importer for finding optionally-vendored
    or otherwise naturally-installed packages from root_name.
    """

    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
        self.root_name = root_name
        self.vendored_names = set(vendored_names)
        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')

    @property
    def search_path(self):
        """
        Search first the vendor package then as a natural package.
        """
        yield self.vendor_pkg + '.'
        yield ''

    def _module_matches_namespace(self, fullname):
        """Figure out if the target module is vendored."""
        root, base, target = fullname.partition(self.root_name + '.')
        return not root and any(map(target.startswith, self.vendored_names))

    def load_module(self, fullname):
        """
        Iterate over the search path to locate and load fullname.
        """
        root, base, target = fullname.partition(self.root_name + '.')
        for prefix in self.search_path:
            try:
                extant = prefix + target
                __import__(extant)
                mod = sys.modules[extant]
                sys.modules[fullname] = mod
                return mod
            except ImportError:
                pass
        else:
            raise ImportError(
                "The '{target}' package is required; "
                "normally this is bundled with this package so if you get "
                "this warning, consult the packager of your "
                "distribution.".format(**locals())
            )

    def create_module(self, spec):
        return self.load_module(spec.name)

    def exec_module(self, module):
        pass

    def find_spec(self, fullname, path=None, target=None):
        """Return a module spec for vendored names."""
        return (
            importlib.util.spec_from_loader(fullname, self)
            if self._module_matches_namespace(fullname)
            else None
        )

    def install(self):
        """
        Install this importer into sys.meta_path if not already present.
        """
        if self not in sys.meta_path:
            sys.meta_path.append(self)


names = (
    'packaging',
    'platformdirs',
    'jaraco',
    'importlib_resources',
    'more_itertools',
)
VendorImporter(__name__, names).install()
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4995484
setuptools-68.1.2/pkg_resources/tests/0000755000175100001730000000000014467657443017473 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/__init__.py0000644000175100001730000000000014467657412021566 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4795473
setuptools-68.1.2/pkg_resources/tests/data/0000755000175100001730000000000014467657443020404 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4995484
setuptools-68.1.2/pkg_resources/tests/data/my-test-package-source/0000755000175100001730000000000014467657443024675 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package-source/setup.cfg0000644000175100001730000000000014467657412026500 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package-source/setup.py0000644000175100001730000000015114467657412026400 0ustar00runnerdockerimport setuptools

setuptools.setup(
    name="my-test-package",
    version="1.0",
    zip_safe=True,
)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4995484
setuptools-68.1.2/pkg_resources/tests/data/my-test-package-zip/0000755000175100001730000000000014467657443024177 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package-zip/my-test-package.zip0000644000175100001730000000342114467657412027712 0ustar00runnerdockerPK
JQmy_test_package.egg-info/UT	/_/_uxPK
JQ2&my_test_package.egg-info/top_level.txtUT	&_&_ux
PK
JQ2-my_test_package.egg-info/dependency_links.txtUT	&_&_ux
PK
JQ2!my_test_package.egg-info/zip-safeUT	&_&_ux
PKJQ&{f$my_test_package.egg-info/SOURCES.txtUT	&_&_ux}A
0нwIzbE
*!ğL{ݽcFP)*շ!ٯݨ{cϳ: b^~J&tHPKJQ^Ɛx!my_test_package.egg-info/PKG-INFOUT	&_&_uxM-ILI,I
K-*ϳR03KMRȭ-I-.-HLNLOBQ\XTi呟
Tr,-/B&f D}2S󊑴'e	$"DPK
FQ	setup.cfgUT	_&_uxPKFQ",Thsetup.pyUT	_w_ux-/*Q(N-)-()B0L
. KMUʭ-I-.-HLNLOU˕g*@2RmCJSu4PK
JQAmy_test_package.egg-info/UT/_uxPK
JQ2&Smy_test_package.egg-info/top_level.txtUT&_uxPK
JQ2-my_test_package.egg-info/dependency_links.txtUT&_uxPK
JQ2!my_test_package.egg-info/zip-safeUT&_uxPKJQ&{f$xmy_test_package.egg-info/SOURCES.txtUT&_uxPKJQ^Ɛx!<my_test_package.egg-info/PKG-INFOUT&_uxPK
FQ	setup.cfgUT_uxPKFQ",ThRsetup.pyUT_uxPK././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4795473
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/0000755000175100001730000000000014467657443026011 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000021400000000000010212 xustar00112 path=setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/
28 mtime=1692360483.4795473
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000755000175100001730000000000014467657443032635 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000022500000000000010214 xustar00121 path=setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/
28 mtime=1692360483.5035486
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000755000175100001730000000000014467657444032636 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000022700000000000010216 xustar00129 path=setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO
22 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001730000000027314467657412032635 0ustar00runnerdockerMetadata-Version: 1.0
Name: my-test-package
Version: 1.0
Summary: UNKNOWN
Home-page: UNKNOWN
Author: UNKNOWN
Author-email: UNKNOWN
License: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
././@PaxHeader0000000000000000000000000000023200000000000010212 xustar00132 path=setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt
22 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001730000000032014467657412032626 0ustar00runnerdockersetup.cfg
setup.py
my_test_package.egg-info/PKG-INFO
my_test_package.egg-info/SOURCES.txt
my_test_package.egg-info/dependency_links.txt
my_test_package.egg-info/top_level.txt
my_test_package.egg-info/zip-safe././@PaxHeader0000000000000000000000000000024300000000000010214 xustar00141 path=setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt
22 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001730000000000114467657412032622 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000023400000000000010214 xustar00134 path=setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt
22 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001730000000000114467657412032622 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000022700000000000010216 xustar00129 path=setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe
22 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.eg0000644000175100001730000000000114467657412032622 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5035486
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_zipped-egg/0000755000175100001730000000000014467657444025513 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg0000644000175100001730000000151314467657412032503 0ustar00runnerdockerPK+O^ƐxEGG-INFO/PKG-INFOM-ILI,I
K-*ϳR03KMRȭ-I-.-HLNLOBQ\XTi呟
Tr,-/B&f D}2S󊑴'e	$"DPK+O&{fEGG-INFO/SOURCES.txt}A
0нwIzbE
*!ğL{ݽcFP)*շ!ٯݨ{cϳ: b^~J&tHPK+O2EGG-INFO/dependency_links.txtPK+O2EGG-INFO/top_level.txtPK+O2EGG-INFO/zip-safePK+O^ƐxEGG-INFO/PKG-INFOPK+O&{fEGG-INFO/SOURCES.txtPK+O2?EGG-INFO/dependency_links.txtPK+O2}EGG-INFO/top_level.txtPK+O2EGG-INFO/zip-safePKO././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/test_find_distributions.py0000644000175100001730000000332114467657412025001 0ustar00runnerdockerimport py
import pytest
import pkg_resources


TESTS_DATA_DIR = py.path.local(__file__).dirpath('data')


class TestFindDistributions:
    @pytest.fixture
    def target_dir(self, tmpdir):
        target_dir = tmpdir.mkdir('target')
        # place a .egg named directory in the target that is not an egg:
        target_dir.mkdir('not.an.egg')
        return target_dir

    def test_non_egg_dir_named_egg(self, target_dir):
        dists = pkg_resources.find_distributions(str(target_dir))
        assert not list(dists)

    def test_standalone_egg_directory(self, target_dir):
        (TESTS_DATA_DIR / 'my-test-package_unpacked-egg').copy(target_dir)
        dists = pkg_resources.find_distributions(str(target_dir))
        assert [dist.project_name for dist in dists] == ['my-test-package']
        dists = pkg_resources.find_distributions(str(target_dir), only=True)
        assert not list(dists)

    def test_zipped_egg(self, target_dir):
        (TESTS_DATA_DIR / 'my-test-package_zipped-egg').copy(target_dir)
        dists = pkg_resources.find_distributions(str(target_dir))
        assert [dist.project_name for dist in dists] == ['my-test-package']
        dists = pkg_resources.find_distributions(str(target_dir), only=True)
        assert not list(dists)

    def test_zipped_sdist_one_level_removed(self, target_dir):
        (TESTS_DATA_DIR / 'my-test-package-zip').copy(target_dir)
        dists = pkg_resources.find_distributions(
            str(target_dir / "my-test-package.zip")
        )
        assert [dist.project_name for dist in dists] == ['my-test-package']
        dists = pkg_resources.find_distributions(
            str(target_dir / "my-test-package.zip"), only=True
        )
        assert not list(dists)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/test_markers.py0000644000175100001730000000036114467657412022544 0ustar00runnerdockerfrom unittest import mock

from pkg_resources import evaluate_marker


@mock.patch('platform.python_version', return_value='2.7.10')
def test_ordering(python_version_mock):
    assert evaluate_marker("python_full_version > '2.7.3'") is True
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/test_pkg_resources.py0000644000175100001730000003367614467657412023772 0ustar00runnerdockerimport sys
import tempfile
import os
import zipfile
import datetime
import time
import subprocess
import stat
import distutils.dist
import distutils.command.install_egg_info

from unittest import mock

from pkg_resources import (
    DistInfoDistribution,
    Distribution,
    EggInfoDistribution,
)

import pytest

import pkg_resources


def timestamp(dt):
    """
    Return a timestamp for a local, naive datetime instance.
    """
    try:
        return dt.timestamp()
    except AttributeError:
        # Python 3.2 and earlier
        return time.mktime(dt.timetuple())


class EggRemover(str):
    def __call__(self):
        if self in sys.path:
            sys.path.remove(self)
        if os.path.exists(self):
            os.remove(self)


class TestZipProvider:
    finalizers = []

    ref_time = datetime.datetime(2013, 5, 12, 13, 25, 0)
    "A reference time for a file modification"

    @classmethod
    def setup_class(cls):
        "create a zip egg and add it to sys.path"
        egg = tempfile.NamedTemporaryFile(suffix='.egg', delete=False)
        zip_egg = zipfile.ZipFile(egg, 'w')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'mod.py'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'x = 3\n')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'data.dat'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'hello, world!')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'subdir/mod2.py'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'x = 6\n')
        zip_info = zipfile.ZipInfo()
        zip_info.filename = 'subdir/data2.dat'
        zip_info.date_time = cls.ref_time.timetuple()
        zip_egg.writestr(zip_info, 'goodbye, world!')
        zip_egg.close()
        egg.close()

        sys.path.append(egg.name)
        subdir = os.path.join(egg.name, 'subdir')
        sys.path.append(subdir)
        cls.finalizers.append(EggRemover(subdir))
        cls.finalizers.append(EggRemover(egg.name))

    @classmethod
    def teardown_class(cls):
        for finalizer in cls.finalizers:
            finalizer()

    def test_resource_listdir(self):
        import mod

        zp = pkg_resources.ZipProvider(mod)

        expected_root = ['data.dat', 'mod.py', 'subdir']
        assert sorted(zp.resource_listdir('')) == expected_root

        expected_subdir = ['data2.dat', 'mod2.py']
        assert sorted(zp.resource_listdir('subdir')) == expected_subdir
        assert sorted(zp.resource_listdir('subdir/')) == expected_subdir

        assert zp.resource_listdir('nonexistent') == []
        assert zp.resource_listdir('nonexistent/') == []

        import mod2

        zp2 = pkg_resources.ZipProvider(mod2)

        assert sorted(zp2.resource_listdir('')) == expected_subdir

        assert zp2.resource_listdir('subdir') == []
        assert zp2.resource_listdir('subdir/') == []

    def test_resource_filename_rewrites_on_change(self):
        """
        If a previous call to get_resource_filename has saved the file, but
        the file has been subsequently mutated with different file of the
        same size and modification time, it should not be overwritten on a
        subsequent call to get_resource_filename.
        """
        import mod

        manager = pkg_resources.ResourceManager()
        zp = pkg_resources.ZipProvider(mod)
        filename = zp.get_resource_filename(manager, 'data.dat')
        actual = datetime.datetime.fromtimestamp(os.stat(filename).st_mtime)
        assert actual == self.ref_time
        f = open(filename, 'w')
        f.write('hello, world?')
        f.close()
        ts = timestamp(self.ref_time)
        os.utime(filename, (ts, ts))
        filename = zp.get_resource_filename(manager, 'data.dat')
        with open(filename) as f:
            assert f.read() == 'hello, world!'
        manager.cleanup_resources()


class TestResourceManager:
    def test_get_cache_path(self):
        mgr = pkg_resources.ResourceManager()
        path = mgr.get_cache_path('foo')
        type_ = str(type(path))
        message = "Unexpected type from get_cache_path: " + type_
        assert isinstance(path, str), message

    def test_get_cache_path_race(self, tmpdir):
        # Patch to os.path.isdir to create a race condition
        def patched_isdir(dirname, unpatched_isdir=pkg_resources.isdir):
            patched_isdir.dirnames.append(dirname)

            was_dir = unpatched_isdir(dirname)
            if not was_dir:
                os.makedirs(dirname)
            return was_dir

        patched_isdir.dirnames = []

        # Get a cache path with a "race condition"
        mgr = pkg_resources.ResourceManager()
        mgr.set_extraction_path(str(tmpdir))

        archive_name = os.sep.join(('foo', 'bar', 'baz'))
        with mock.patch.object(pkg_resources, 'isdir', new=patched_isdir):
            mgr.get_cache_path(archive_name)

        # Because this test relies on the implementation details of this
        # function, these assertions are a sentinel to ensure that the
        # test suite will not fail silently if the implementation changes.
        called_dirnames = patched_isdir.dirnames
        assert len(called_dirnames) == 2
        assert called_dirnames[0].split(os.sep)[-2:] == ['foo', 'bar']
        assert called_dirnames[1].split(os.sep)[-1:] == ['foo']

    """
    Tests to ensure that pkg_resources runs independently from setuptools.
    """

    def test_setuptools_not_imported(self):
        """
        In a separate Python environment, import pkg_resources and assert
        that action doesn't cause setuptools to be imported.
        """
        lines = (
            'import pkg_resources',
            'import sys',
            ('assert "setuptools" not in sys.modules, ' '"setuptools was imported"'),
        )
        cmd = [sys.executable, '-c', '; '.join(lines)]
        subprocess.check_call(cmd)


def make_test_distribution(metadata_path, metadata):
    """
    Make a test Distribution object, and return it.

    :param metadata_path: the path to the metadata file that should be
        created. This should be inside a distribution directory that should
        also be created. For example, an argument value might end with
        ".dist-info/METADATA".
    :param metadata: the desired contents of the metadata file, as bytes.
    """
    dist_dir = os.path.dirname(metadata_path)
    os.mkdir(dist_dir)
    with open(metadata_path, 'wb') as f:
        f.write(metadata)
    dists = list(pkg_resources.distributions_from_metadata(dist_dir))
    (dist,) = dists

    return dist


def test_get_metadata__bad_utf8(tmpdir):
    """
    Test a metadata file with bytes that can't be decoded as utf-8.
    """
    filename = 'METADATA'
    # Convert the tmpdir LocalPath object to a string before joining.
    metadata_path = os.path.join(str(tmpdir), 'foo.dist-info', filename)
    # Encode a non-ascii string with the wrong encoding (not utf-8).
    metadata = 'née'.encode('iso-8859-1')
    dist = make_test_distribution(metadata_path, metadata=metadata)

    with pytest.raises(UnicodeDecodeError) as excinfo:
        dist.get_metadata(filename)

    exc = excinfo.value
    actual = str(exc)
    expected = (
        # The error message starts with "'utf-8' codec ..." However, the
        # spelling of "utf-8" can vary (e.g. "utf8") so we don't include it
        "codec can't decode byte 0xe9 in position 1: "
        'invalid continuation byte in METADATA file at path: '
    )
    assert expected in actual, 'actual: {}'.format(actual)
    assert actual.endswith(metadata_path), 'actual: {}'.format(actual)


def make_distribution_no_version(tmpdir, basename):
    """
    Create a distribution directory with no file containing the version.
    """
    dist_dir = tmpdir / basename
    dist_dir.ensure_dir()
    # Make the directory non-empty so distributions_from_metadata()
    # will detect it and yield it.
    dist_dir.join('temp.txt').ensure()

    if sys.version_info < (3, 6):
        dist_dir = str(dist_dir)

    dists = list(pkg_resources.distributions_from_metadata(dist_dir))
    assert len(dists) == 1
    (dist,) = dists

    return dist, dist_dir


@pytest.mark.parametrize(
    'suffix, expected_filename, expected_dist_type',
    [
        ('egg-info', 'PKG-INFO', EggInfoDistribution),
        ('dist-info', 'METADATA', DistInfoDistribution),
    ],
)
@pytest.mark.xfail(
    sys.version_info[:2] == (3, 12) and sys.version_info.releaselevel != 'final',
    reason="https://github.com/python/cpython/issues/103632",
)
def test_distribution_version_missing(
    tmpdir, suffix, expected_filename, expected_dist_type
):
    """
    Test Distribution.version when the "Version" header is missing.
    """
    basename = 'foo.{}'.format(suffix)
    dist, dist_dir = make_distribution_no_version(tmpdir, basename)

    expected_text = ("Missing 'Version:' header and/or {} file at path: ").format(
        expected_filename
    )
    metadata_path = os.path.join(dist_dir, expected_filename)

    # Now check the exception raised when the "version" attribute is accessed.
    with pytest.raises(ValueError) as excinfo:
        dist.version

    err = str(excinfo.value)
    # Include a string expression after the assert so the full strings
    # will be visible for inspection on failure.
    assert expected_text in err, str((expected_text, err))

    # Also check the args passed to the ValueError.
    msg, dist = excinfo.value.args
    assert expected_text in msg
    # Check that the message portion contains the path.
    assert metadata_path in msg, str((metadata_path, msg))
    assert type(dist) == expected_dist_type


@pytest.mark.xfail(
    sys.version_info[:2] == (3, 12) and sys.version_info.releaselevel != 'final',
    reason="https://github.com/python/cpython/issues/103632",
)
def test_distribution_version_missing_undetected_path():
    """
    Test Distribution.version when the "Version" header is missing and
    the path can't be detected.
    """
    # Create a Distribution object with no metadata argument, which results
    # in an empty metadata provider.
    dist = Distribution('/foo')
    with pytest.raises(ValueError) as excinfo:
        dist.version

    msg, dist = excinfo.value.args
    expected = (
        "Missing 'Version:' header and/or PKG-INFO file at path: " '[could not detect]'
    )
    assert msg == expected


@pytest.mark.parametrize('only', [False, True])
def test_dist_info_is_not_dir(tmp_path, only):
    """Test path containing a file with dist-info extension."""
    dist_info = tmp_path / 'foobar.dist-info'
    dist_info.touch()
    assert not pkg_resources.dist_factory(str(tmp_path), str(dist_info), only)


class TestDeepVersionLookupDistutils:
    @pytest.fixture
    def env(self, tmpdir):
        """
        Create a package environment, similar to a virtualenv,
        in which packages are installed.
        """

        class Environment(str):
            pass

        env = Environment(tmpdir)
        tmpdir.chmod(stat.S_IRWXU)
        subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
        env.paths = dict((dirname, str(tmpdir / dirname)) for dirname in subs)
        list(map(os.mkdir, env.paths.values()))
        return env

    def create_foo_pkg(self, env, version):
        """
        Create a foo package installed (distutils-style) to env.paths['lib']
        as version.
        """
        ld = "This package has unicode metadata! ❄"
        attrs = dict(name='foo', version=version, long_description=ld)
        dist = distutils.dist.Distribution(attrs)
        iei_cmd = distutils.command.install_egg_info.install_egg_info(dist)
        iei_cmd.initialize_options()
        iei_cmd.install_dir = env.paths['lib']
        iei_cmd.finalize_options()
        iei_cmd.run()

    def test_version_resolved_from_egg_info(self, env):
        version = '1.11.0.dev0+2329eae'
        self.create_foo_pkg(env, version)

        # this requirement parsing will raise a VersionConflict unless the
        # .egg-info file is parsed (see #419 on BitBucket)
        req = pkg_resources.Requirement.parse('foo>=1.9')
        dist = pkg_resources.WorkingSet([env.paths['lib']]).find(req)
        assert dist.version == version

    @pytest.mark.parametrize(
        'unnormalized, normalized',
        [
            ('foo', 'foo'),
            ('foo/', 'foo'),
            ('foo/bar', 'foo/bar'),
            ('foo/bar/', 'foo/bar'),
        ],
    )
    def test_normalize_path_trailing_sep(self, unnormalized, normalized):
        """Ensure the trailing slash is cleaned for path comparison.

        See pypa/setuptools#1519.
        """
        result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
        result_from_normalized = pkg_resources.normalize_path(normalized)
        assert result_from_unnormalized == result_from_normalized

    @pytest.mark.skipif(
        os.path.normcase('A') != os.path.normcase('a'),
        reason='Testing case-insensitive filesystems.',
    )
    @pytest.mark.parametrize(
        'unnormalized, normalized',
        [
            ('MiXeD/CasE', 'mixed/case'),
        ],
    )
    def test_normalize_path_normcase(self, unnormalized, normalized):
        """Ensure mixed case is normalized on case-insensitive filesystems."""
        result_from_unnormalized = pkg_resources.normalize_path(unnormalized)
        result_from_normalized = pkg_resources.normalize_path(normalized)
        assert result_from_unnormalized == result_from_normalized

    @pytest.mark.skipif(
        os.path.sep != '\\',
        reason='Testing systems using backslashes as path separators.',
    )
    @pytest.mark.parametrize(
        'unnormalized, expected',
        [
            ('forward/slash', 'forward\\slash'),
            ('forward/slash/', 'forward\\slash'),
            ('backward\\slash\\', 'backward\\slash'),
        ],
    )
    def test_normalize_path_backslash_sep(self, unnormalized, expected):
        """Ensure path seps are cleaned on backslash path sep systems."""
        result = pkg_resources.normalize_path(unnormalized)
        assert result.endswith(expected)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/test_resources.py0000644000175100001730000007502614467657412023124 0ustar00runnerdockerimport os
import sys
import string
import platform
import itertools

import pytest
from pkg_resources.extern import packaging

import pkg_resources
from pkg_resources import (
    parse_requirements,
    VersionConflict,
    parse_version,
    Distribution,
    EntryPoint,
    Requirement,
    safe_version,
    safe_name,
    WorkingSet,
)


# from Python 3.6 docs.
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = itertools.tee(iterable)
    next(b, None)
    return zip(a, b)


class Metadata(pkg_resources.EmptyProvider):
    """Mock object to return metadata as if from an on-disk distribution"""

    def __init__(self, *pairs):
        self.metadata = dict(pairs)

    def has_metadata(self, name):
        return name in self.metadata

    def get_metadata(self, name):
        return self.metadata[name]

    def get_metadata_lines(self, name):
        return pkg_resources.yield_lines(self.get_metadata(name))


dist_from_fn = pkg_resources.Distribution.from_filename


class TestDistro:
    def testCollection(self):
        # empty path should produce no distributions
        ad = pkg_resources.Environment([], platform=None, python=None)
        assert list(ad) == []
        assert ad['FooPkg'] == []
        ad.add(dist_from_fn("FooPkg-1.3_1.egg"))
        ad.add(dist_from_fn("FooPkg-1.4-py2.4-win32.egg"))
        ad.add(dist_from_fn("FooPkg-1.2-py2.4.egg"))

        # Name is in there now
        assert ad['FooPkg']
        # But only 1 package
        assert list(ad) == ['foopkg']

        # Distributions sort by version
        expected = ['1.4', '1.3-1', '1.2']
        assert [dist.version for dist in ad['FooPkg']] == expected

        # Removing a distribution leaves sequence alone
        ad.remove(ad['FooPkg'][1])
        assert [dist.version for dist in ad['FooPkg']] == ['1.4', '1.2']

        # And inserting adds them in order
        ad.add(dist_from_fn("FooPkg-1.9.egg"))
        assert [dist.version for dist in ad['FooPkg']] == ['1.9', '1.4', '1.2']

        ws = WorkingSet([])
        foo12 = dist_from_fn("FooPkg-1.2-py2.4.egg")
        foo14 = dist_from_fn("FooPkg-1.4-py2.4-win32.egg")
        (req,) = parse_requirements("FooPkg>=1.3")

        # Nominal case: no distros on path, should yield all applicable
        assert ad.best_match(req, ws).version == '1.9'
        # If a matching distro is already installed, should return only that
        ws.add(foo14)
        assert ad.best_match(req, ws).version == '1.4'

        # If the first matching distro is unsuitable, it's a version conflict
        ws = WorkingSet([])
        ws.add(foo12)
        ws.add(foo14)
        with pytest.raises(VersionConflict):
            ad.best_match(req, ws)

        # If more than one match on the path, the first one takes precedence
        ws = WorkingSet([])
        ws.add(foo14)
        ws.add(foo12)
        ws.add(foo14)
        assert ad.best_match(req, ws).version == '1.4'

    def checkFooPkg(self, d):
        assert d.project_name == "FooPkg"
        assert d.key == "foopkg"
        assert d.version == "1.3.post1"
        assert d.py_version == "2.4"
        assert d.platform == "win32"
        assert d.parsed_version == parse_version("1.3-1")

    def testDistroBasics(self):
        d = Distribution(
            "/some/path",
            project_name="FooPkg",
            version="1.3-1",
            py_version="2.4",
            platform="win32",
        )
        self.checkFooPkg(d)

        d = Distribution("/some/path")
        assert d.py_version == '{}.{}'.format(*sys.version_info)
        assert d.platform is None

    def testDistroParse(self):
        d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg")
        self.checkFooPkg(d)
        d = dist_from_fn("FooPkg-1.3.post1-py2.4-win32.egg-info")
        self.checkFooPkg(d)

    def testDistroMetadata(self):
        d = Distribution(
            "/some/path",
            project_name="FooPkg",
            py_version="2.4",
            platform="win32",
            metadata=Metadata(('PKG-INFO', "Metadata-Version: 1.0\nVersion: 1.3-1\n")),
        )
        self.checkFooPkg(d)

    def distRequires(self, txt):
        return Distribution("/foo", metadata=Metadata(('depends.txt', txt)))

    def checkRequires(self, dist, txt, extras=()):
        assert list(dist.requires(extras)) == list(parse_requirements(txt))

    def testDistroDependsSimple(self):
        for v in "Twisted>=1.5", "Twisted>=1.5\nZConfig>=2.0":
            self.checkRequires(self.distRequires(v), v)

    needs_object_dir = pytest.mark.skipif(
        not hasattr(object, '__dir__'),
        reason='object.__dir__ necessary for self.__dir__ implementation',
    )

    def test_distribution_dir(self):
        d = pkg_resources.Distribution()
        dir(d)

    @needs_object_dir
    def test_distribution_dir_includes_provider_dir(self):
        d = pkg_resources.Distribution()
        before = d.__dir__()
        assert 'test_attr' not in before
        d._provider.test_attr = None
        after = d.__dir__()
        assert len(after) == len(before) + 1
        assert 'test_attr' in after

    @needs_object_dir
    def test_distribution_dir_ignores_provider_dir_leading_underscore(self):
        d = pkg_resources.Distribution()
        before = d.__dir__()
        assert '_test_attr' not in before
        d._provider._test_attr = None
        after = d.__dir__()
        assert len(after) == len(before)
        assert '_test_attr' not in after

    def testResolve(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        # Resolving no requirements -> nothing to install
        assert list(ws.resolve([], ad)) == []
        # Request something not in the collection -> DistributionNotFound
        with pytest.raises(pkg_resources.DistributionNotFound):
            ws.resolve(parse_requirements("Foo"), ad)

        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.egg",
            metadata=Metadata(('depends.txt', "[bar]\nBaz>=2.0")),
        )
        ad.add(Foo)
        ad.add(Distribution.from_filename("Foo-0.9.egg"))

        # Request thing(s) that are available -> list to activate
        for i in range(3):
            targets = list(ws.resolve(parse_requirements("Foo"), ad))
            assert targets == [Foo]
            list(map(ws.add, targets))
        with pytest.raises(VersionConflict):
            ws.resolve(parse_requirements("Foo==0.9"), ad)
        ws = WorkingSet([])  # reset

        # Request an extra that causes an unresolved dependency for "Baz"
        with pytest.raises(pkg_resources.DistributionNotFound):
            ws.resolve(parse_requirements("Foo[bar]"), ad)
        Baz = Distribution.from_filename(
            "/foo_dir/Baz-2.1.egg", metadata=Metadata(('depends.txt', "Foo"))
        )
        ad.add(Baz)

        # Activation list now includes resolved dependency
        assert list(ws.resolve(parse_requirements("Foo[bar]"), ad)) == [Foo, Baz]
        # Requests for conflicting versions produce VersionConflict
        with pytest.raises(VersionConflict) as vc:
            ws.resolve(parse_requirements("Foo==1.2\nFoo!=1.2"), ad)

        msg = 'Foo 0.9 is installed but Foo==1.2 is required'
        assert vc.value.report() == msg

    def test_environment_marker_evaluation_negative(self):
        """Environment markers are evaluated at resolution time."""
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        res = ws.resolve(parse_requirements("Foo;python_version<'2'"), ad)
        assert list(res) == []

    def test_environment_marker_evaluation_positive(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename("/foo_dir/Foo-1.2.dist-info")
        ad.add(Foo)
        res = ws.resolve(parse_requirements("Foo;python_version>='2'"), ad)
        assert list(res) == [Foo]

    def test_environment_marker_evaluation_called(self):
        """
        If one package foo requires bar without any extras,
        markers should pass for bar without extras.
        """
        (parent_req,) = parse_requirements("foo")
        (req,) = parse_requirements("bar;python_version>='2'")
        req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
        assert req_extras.markers_pass(req)

        (parent_req,) = parse_requirements("foo[]")
        (req,) = parse_requirements("bar;python_version>='2'")
        req_extras = pkg_resources._ReqExtras({req: parent_req.extras})
        assert req_extras.markers_pass(req)

    def test_marker_evaluation_with_extras(self):
        """Extras are also evaluated as markers at resolution time."""
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.dist-info",
            metadata=Metadata(
                (
                    "METADATA",
                    "Provides-Extra: baz\n" "Requires-Dist: quux; extra=='baz'",
                )
            ),
        )
        ad.add(Foo)
        assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
        ad.add(quux)
        res = list(ws.resolve(parse_requirements("Foo[baz]"), ad))
        assert res == [Foo, quux]

    def test_marker_evaluation_with_extras_normlized(self):
        """Extras are also evaluated as markers at resolution time."""
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.dist-info",
            metadata=Metadata(
                (
                    "METADATA",
                    "Provides-Extra: baz-lightyear\n"
                    "Requires-Dist: quux; extra=='baz-lightyear'",
                )
            ),
        )
        ad.add(Foo)
        assert list(ws.resolve(parse_requirements("Foo"), ad)) == [Foo]
        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
        ad.add(quux)
        res = list(ws.resolve(parse_requirements("Foo[baz-lightyear]"), ad))
        assert res == [Foo, quux]

    def test_marker_evaluation_with_multiple_extras(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        Foo = Distribution.from_filename(
            "/foo_dir/Foo-1.2.dist-info",
            metadata=Metadata(
                (
                    "METADATA",
                    "Provides-Extra: baz\n"
                    "Requires-Dist: quux; extra=='baz'\n"
                    "Provides-Extra: bar\n"
                    "Requires-Dist: fred; extra=='bar'\n",
                )
            ),
        )
        ad.add(Foo)
        quux = Distribution.from_filename("/foo_dir/quux-1.0.dist-info")
        ad.add(quux)
        fred = Distribution.from_filename("/foo_dir/fred-0.1.dist-info")
        ad.add(fred)
        res = list(ws.resolve(parse_requirements("Foo[baz,bar]"), ad))
        assert sorted(res) == [fred, quux, Foo]

    def test_marker_evaluation_with_extras_loop(self):
        ad = pkg_resources.Environment([])
        ws = WorkingSet([])
        a = Distribution.from_filename(
            "/foo_dir/a-0.2.dist-info",
            metadata=Metadata(("METADATA", "Requires-Dist: c[a]")),
        )
        b = Distribution.from_filename(
            "/foo_dir/b-0.3.dist-info",
            metadata=Metadata(("METADATA", "Requires-Dist: c[b]")),
        )
        c = Distribution.from_filename(
            "/foo_dir/c-1.0.dist-info",
            metadata=Metadata(
                (
                    "METADATA",
                    "Provides-Extra: a\n"
                    "Requires-Dist: b;extra=='a'\n"
                    "Provides-Extra: b\n"
                    "Requires-Dist: foo;extra=='b'",
                )
            ),
        )
        foo = Distribution.from_filename("/foo_dir/foo-0.1.dist-info")
        for dist in (a, b, c, foo):
            ad.add(dist)
        res = list(ws.resolve(parse_requirements("a"), ad))
        assert res == [a, c, b, foo]

    @pytest.mark.xfail(
        sys.version_info[:2] == (3, 12) and sys.version_info.releaselevel != 'final',
        reason="https://github.com/python/cpython/issues/103632",
    )
    def testDistroDependsOptions(self):
        d = self.distRequires(
            """
            Twisted>=1.5
            [docgen]
            ZConfig>=2.0
            docutils>=0.3
            [fastcgi]
            fcgiapp>=0.1"""
        )
        self.checkRequires(d, "Twisted>=1.5")
        self.checkRequires(
            d, "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3".split(), ["docgen"]
        )
        self.checkRequires(d, "Twisted>=1.5 fcgiapp>=0.1".split(), ["fastcgi"])
        self.checkRequires(
            d,
            "Twisted>=1.5 ZConfig>=2.0 docutils>=0.3 fcgiapp>=0.1".split(),
            ["docgen", "fastcgi"],
        )
        self.checkRequires(
            d,
            "Twisted>=1.5 fcgiapp>=0.1 ZConfig>=2.0 docutils>=0.3".split(),
            ["fastcgi", "docgen"],
        )
        with pytest.raises(pkg_resources.UnknownExtra):
            d.requires(["foo"])


class TestWorkingSet:
    def test_find_conflicting(self):
        ws = WorkingSet([])
        Foo = Distribution.from_filename("/foo_dir/Foo-1.2.egg")
        ws.add(Foo)

        # create a requirement that conflicts with Foo 1.2
        req = next(parse_requirements("Foo<1.2"))

        with pytest.raises(VersionConflict) as vc:
            ws.find(req)

        msg = 'Foo 1.2 is installed but Foo<1.2 is required'
        assert vc.value.report() == msg

    def test_resolve_conflicts_with_prior(self):
        """
        A ContextualVersionConflict should be raised when a requirement
        conflicts with a prior requirement for a different package.
        """
        # Create installation where Foo depends on Baz 1.0 and Bar depends on
        # Baz 2.0.
        ws = WorkingSet([])
        md = Metadata(('depends.txt', "Baz==1.0"))
        Foo = Distribution.from_filename("/foo_dir/Foo-1.0.egg", metadata=md)
        ws.add(Foo)
        md = Metadata(('depends.txt', "Baz==2.0"))
        Bar = Distribution.from_filename("/foo_dir/Bar-1.0.egg", metadata=md)
        ws.add(Bar)
        Baz = Distribution.from_filename("/foo_dir/Baz-1.0.egg")
        ws.add(Baz)
        Baz = Distribution.from_filename("/foo_dir/Baz-2.0.egg")
        ws.add(Baz)

        with pytest.raises(VersionConflict) as vc:
            ws.resolve(parse_requirements("Foo\nBar\n"))

        msg = "Baz 1.0 is installed but Baz==2.0 is required by "
        msg += repr(set(['Bar']))
        assert vc.value.report() == msg


class TestEntryPoints:
    def assertfields(self, ep):
        assert ep.name == "foo"
        assert ep.module_name == "pkg_resources.tests.test_resources"
        assert ep.attrs == ("TestEntryPoints",)
        assert ep.extras == ("x",)
        assert ep.load() is TestEntryPoints
        expect = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
        assert str(ep) == expect

    def setup_method(self, method):
        self.dist = Distribution.from_filename(
            "FooPkg-1.2-py2.4.egg", metadata=Metadata(('requires.txt', '[x]'))
        )

    def testBasics(self):
        ep = EntryPoint(
            "foo",
            "pkg_resources.tests.test_resources",
            ["TestEntryPoints"],
            ["x"],
            self.dist,
        )
        self.assertfields(ep)

    def testParse(self):
        s = "foo = pkg_resources.tests.test_resources:TestEntryPoints [x]"
        ep = EntryPoint.parse(s, self.dist)
        self.assertfields(ep)

        ep = EntryPoint.parse("bar baz=  spammity[PING]")
        assert ep.name == "bar baz"
        assert ep.module_name == "spammity"
        assert ep.attrs == ()
        assert ep.extras == ("ping",)

        ep = EntryPoint.parse(" fizzly =  wocka:foo")
        assert ep.name == "fizzly"
        assert ep.module_name == "wocka"
        assert ep.attrs == ("foo",)
        assert ep.extras == ()

        # plus in the name
        spec = "html+mako = mako.ext.pygmentplugin:MakoHtmlLexer"
        ep = EntryPoint.parse(spec)
        assert ep.name == 'html+mako'

    reject_specs = "foo", "x=a:b:c", "q=x/na", "fez=pish:tush-z", "x=f[a]>2"

    @pytest.mark.parametrize("reject_spec", reject_specs)
    def test_reject_spec(self, reject_spec):
        with pytest.raises(ValueError):
            EntryPoint.parse(reject_spec)

    def test_printable_name(self):
        """
        Allow any printable character in the name.
        """
        # Create a name with all printable characters; strip the whitespace.
        name = string.printable.strip()
        spec = "{name} = module:attr".format(**locals())
        ep = EntryPoint.parse(spec)
        assert ep.name == name

    def checkSubMap(self, m):
        assert len(m) == len(self.submap_expect)
        for key, ep in self.submap_expect.items():
            assert m.get(key).name == ep.name
            assert m.get(key).module_name == ep.module_name
            assert sorted(m.get(key).attrs) == sorted(ep.attrs)
            assert sorted(m.get(key).extras) == sorted(ep.extras)

    submap_expect = dict(
        feature1=EntryPoint('feature1', 'somemodule', ['somefunction']),
        feature2=EntryPoint(
            'feature2', 'another.module', ['SomeClass'], ['extra1', 'extra2']
        ),
        feature3=EntryPoint('feature3', 'this.module', extras=['something']),
    )
    submap_str = """
            # define features for blah blah
            feature1 = somemodule:somefunction
            feature2 = another.module:SomeClass [extra1,extra2]
            feature3 = this.module [something]
    """

    def testParseList(self):
        self.checkSubMap(EntryPoint.parse_group("xyz", self.submap_str))
        with pytest.raises(ValueError):
            EntryPoint.parse_group("x a", "foo=bar")
        with pytest.raises(ValueError):
            EntryPoint.parse_group("x", ["foo=baz", "foo=bar"])

    def testParseMap(self):
        m = EntryPoint.parse_map({'xyz': self.submap_str})
        self.checkSubMap(m['xyz'])
        assert list(m.keys()) == ['xyz']
        m = EntryPoint.parse_map("[xyz]\n" + self.submap_str)
        self.checkSubMap(m['xyz'])
        assert list(m.keys()) == ['xyz']
        with pytest.raises(ValueError):
            EntryPoint.parse_map(["[xyz]", "[xyz]"])
        with pytest.raises(ValueError):
            EntryPoint.parse_map(self.submap_str)

    def testDeprecationWarnings(self):
        ep = EntryPoint(
            "foo", "pkg_resources.tests.test_resources", ["TestEntryPoints"], ["x"]
        )
        with pytest.warns(pkg_resources.PkgResourcesDeprecationWarning):
            ep.load(require=False)


class TestRequirements:
    def testBasics(self):
        r = Requirement.parse("Twisted>=1.2")
        assert str(r) == "Twisted>=1.2"
        assert repr(r) == "Requirement.parse('Twisted>=1.2')"
        assert r == Requirement("Twisted>=1.2")
        assert r == Requirement("twisTed>=1.2")
        assert r != Requirement("Twisted>=2.0")
        assert r != Requirement("Zope>=1.2")
        assert r != Requirement("Zope>=3.0")
        assert r != Requirement("Twisted[extras]>=1.2")

    def testOrdering(self):
        r1 = Requirement("Twisted==1.2c1,>=1.2")
        r2 = Requirement("Twisted>=1.2,==1.2c1")
        assert r1 == r2
        assert str(r1) == str(r2)
        assert str(r2) == "Twisted==1.2c1,>=1.2"
        assert Requirement("Twisted") != Requirement(
            "Twisted @ https://localhost/twisted.zip"
        )

    def testBasicContains(self):
        r = Requirement("Twisted>=1.2")
        foo_dist = Distribution.from_filename("FooPkg-1.3_1.egg")
        twist11 = Distribution.from_filename("Twisted-1.1.egg")
        twist12 = Distribution.from_filename("Twisted-1.2.egg")
        assert parse_version('1.2') in r
        assert parse_version('1.1') not in r
        assert '1.2' in r
        assert '1.1' not in r
        assert foo_dist not in r
        assert twist11 not in r
        assert twist12 in r

    def testOptionsAndHashing(self):
        r1 = Requirement.parse("Twisted[foo,bar]>=1.2")
        r2 = Requirement.parse("Twisted[bar,FOO]>=1.2")
        assert r1 == r2
        assert set(r1.extras) == set(("foo", "bar"))
        assert set(r2.extras) == set(("foo", "bar"))
        assert hash(r1) == hash(r2)
        assert hash(r1) == hash(
            (
                "twisted",
                None,
                packaging.specifiers.SpecifierSet(">=1.2"),
                frozenset(["foo", "bar"]),
                None,
            )
        )
        assert hash(
            Requirement.parse("Twisted @ https://localhost/twisted.zip")
        ) == hash(
            (
                "twisted",
                "https://localhost/twisted.zip",
                packaging.specifiers.SpecifierSet(),
                frozenset(),
                None,
            )
        )

    def testVersionEquality(self):
        r1 = Requirement.parse("foo==0.3a2")
        r2 = Requirement.parse("foo!=0.3a4")
        d = Distribution.from_filename

        assert d("foo-0.3a4.egg") not in r1
        assert d("foo-0.3a1.egg") not in r1
        assert d("foo-0.3a4.egg") not in r2

        assert d("foo-0.3a2.egg") in r1
        assert d("foo-0.3a2.egg") in r2
        assert d("foo-0.3a3.egg") in r2
        assert d("foo-0.3a5.egg") in r2

    def testSetuptoolsProjectName(self):
        """
        The setuptools project should implement the setuptools package.
        """

        assert Requirement.parse('setuptools').project_name == 'setuptools'
        # setuptools 0.7 and higher means setuptools.
        assert Requirement.parse('setuptools == 0.7').project_name == 'setuptools'
        assert Requirement.parse('setuptools == 0.7a1').project_name == 'setuptools'
        assert Requirement.parse('setuptools >= 0.7').project_name == 'setuptools'


class TestParsing:
    def testEmptyParse(self):
        assert list(parse_requirements('')) == []

    def testYielding(self):
        for inp, out in [
            ([], []),
            ('x', ['x']),
            ([[]], []),
            (' x\n y', ['x', 'y']),
            (['x\n\n', 'y'], ['x', 'y']),
        ]:
            assert list(pkg_resources.yield_lines(inp)) == out

    def testSplitting(self):
        sample = """
                    x
                    [Y]
                    z

                    a
                    [b ]
                    # foo
                    c
                    [ d]
                    [q]
                    v
                    """
        assert list(pkg_resources.split_sections(sample)) == [
            (None, ["x"]),
            ("Y", ["z", "a"]),
            ("b", ["c"]),
            ("d", []),
            ("q", ["v"]),
        ]
        with pytest.raises(ValueError):
            list(pkg_resources.split_sections("[foo"))

    def testSafeName(self):
        assert safe_name("adns-python") == "adns-python"
        assert safe_name("WSGI Utils") == "WSGI-Utils"
        assert safe_name("WSGI  Utils") == "WSGI-Utils"
        assert safe_name("Money$$$Maker") == "Money-Maker"
        assert safe_name("peak.web") != "peak-web"

    def testSafeVersion(self):
        assert safe_version("1.2-1") == "1.2.post1"
        assert safe_version("1.2 alpha") == "1.2.alpha"
        assert safe_version("2.3.4 20050521") == "2.3.4.20050521"
        assert safe_version("Money$$$Maker") == "Money-Maker"
        assert safe_version("peak.web") == "peak.web"

    def testSimpleRequirements(self):
        assert list(parse_requirements('Twis-Ted>=1.2-1')) == [
            Requirement('Twis-Ted>=1.2-1')
        ]
        assert list(parse_requirements('Twisted >=1.2, \\ # more\n<2.0')) == [
            Requirement('Twisted>=1.2,<2.0')
        ]
        assert Requirement.parse("FooBar==1.99a3") == Requirement("FooBar==1.99a3")
        with pytest.raises(ValueError):
            Requirement.parse(">=2.3")
        with pytest.raises(ValueError):
            Requirement.parse("x\\")
        with pytest.raises(ValueError):
            Requirement.parse("x==2 q")
        with pytest.raises(ValueError):
            Requirement.parse("X==1\nY==2")
        with pytest.raises(ValueError):
            Requirement.parse("#")

    def test_requirements_with_markers(self):
        assert Requirement.parse("foobar;os_name=='a'") == Requirement.parse(
            "foobar;os_name=='a'"
        )
        assert Requirement.parse(
            "name==1.1;python_version=='2.7'"
        ) != Requirement.parse("name==1.1;python_version=='3.6'")
        assert Requirement.parse(
            "name==1.0;python_version=='2.7'"
        ) != Requirement.parse("name==1.2;python_version=='2.7'")
        assert Requirement.parse(
            "name[foo]==1.0;python_version=='3.6'"
        ) != Requirement.parse("name[foo,bar]==1.0;python_version=='3.6'")

    def test_local_version(self):
        (req,) = parse_requirements('foo==1.0+org1')

    def test_spaces_between_multiple_versions(self):
        (req,) = parse_requirements('foo>=1.0, <3')
        (req,) = parse_requirements('foo >= 1.0, < 3')

    @pytest.mark.parametrize(
        ['lower', 'upper'],
        [
            ('1.2-rc1', '1.2rc1'),
            ('0.4', '0.4.0'),
            ('0.4.0.0', '0.4.0'),
            ('0.4.0-0', '0.4-0'),
            ('0post1', '0.0post1'),
            ('0pre1', '0.0c1'),
            ('0.0.0preview1', '0c1'),
            ('0.0c1', '0-rc1'),
            ('1.2a1', '1.2.a.1'),
            ('1.2.a', '1.2a'),
        ],
    )
    def testVersionEquality(self, lower, upper):
        assert parse_version(lower) == parse_version(upper)

    torture = """
        0.80.1-3 0.80.1-2 0.80.1-1 0.79.9999+0.80.0pre4-1
        0.79.9999+0.80.0pre2-3 0.79.9999+0.80.0pre2-2
        0.77.2-1 0.77.1-1 0.77.0-1
        """

    @pytest.mark.parametrize(
        ['lower', 'upper'],
        [
            ('2.1', '2.1.1'),
            ('2a1', '2b0'),
            ('2a1', '2.1'),
            ('2.3a1', '2.3'),
            ('2.1-1', '2.1-2'),
            ('2.1-1', '2.1.1'),
            ('2.1', '2.1post4'),
            ('2.1a0-20040501', '2.1'),
            ('1.1', '02.1'),
            ('3.2', '3.2.post0'),
            ('3.2post1', '3.2post2'),
            ('0.4', '4.0'),
            ('0.0.4', '0.4.0'),
            ('0post1', '0.4post1'),
            ('2.1.0-rc1', '2.1.0'),
            ('2.1dev', '2.1a0'),
        ]
        + list(pairwise(reversed(torture.split()))),
    )
    def testVersionOrdering(self, lower, upper):
        assert parse_version(lower) < parse_version(upper)

    def testVersionHashable(self):
        """
        Ensure that our versions stay hashable even though we've subclassed
        them and added some shim code to them.
        """
        assert hash(parse_version("1.0")) == hash(parse_version("1.0"))


class TestNamespaces:
    ns_str = "__import__('pkg_resources').declare_namespace(__name__)\n"

    @pytest.fixture
    def symlinked_tmpdir(self, tmpdir):
        """
        Where available, return the tempdir as a symlink,
        which as revealed in #231 is more fragile than
        a natural tempdir.
        """
        if not hasattr(os, 'symlink'):
            yield str(tmpdir)
            return

        link_name = str(tmpdir) + '-linked'
        os.symlink(str(tmpdir), link_name)
        try:
            yield type(tmpdir)(link_name)
        finally:
            os.unlink(link_name)

    @pytest.fixture(autouse=True)
    def patched_path(self, tmpdir):
        """
        Patch sys.path to include the 'site-pkgs' dir. Also
        restore pkg_resources._namespace_packages to its
        former state.
        """
        saved_ns_pkgs = pkg_resources._namespace_packages.copy()
        saved_sys_path = sys.path[:]
        site_pkgs = tmpdir.mkdir('site-pkgs')
        sys.path.append(str(site_pkgs))
        try:
            yield
        finally:
            pkg_resources._namespace_packages = saved_ns_pkgs
            sys.path = saved_sys_path

    issue591 = pytest.mark.xfail(platform.system() == 'Windows', reason="#591")

    @issue591
    def test_two_levels_deep(self, symlinked_tmpdir):
        """
        Test nested namespace packages
        Create namespace packages in the following tree :
            site-packages-1/pkg1/pkg2
            site-packages-2/pkg1/pkg2
        Check both are in the _namespace_packages dict and that their __path__
        is correct
        """
        real_tmpdir = symlinked_tmpdir.realpath()
        tmpdir = symlinked_tmpdir
        sys.path.append(str(tmpdir / 'site-pkgs2'))
        site_dirs = tmpdir / 'site-pkgs', tmpdir / 'site-pkgs2'
        for site in site_dirs:
            pkg1 = site / 'pkg1'
            pkg2 = pkg1 / 'pkg2'
            pkg2.ensure_dir()
            (pkg1 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
            (pkg2 / '__init__.py').write_text(self.ns_str, encoding='utf-8')
        with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
            import pkg1
        assert "pkg1" in pkg_resources._namespace_packages
        # attempt to import pkg2 from site-pkgs2
        with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
            import pkg1.pkg2
        # check the _namespace_packages dict
        assert "pkg1.pkg2" in pkg_resources._namespace_packages
        assert pkg_resources._namespace_packages["pkg1"] == ["pkg1.pkg2"]
        # check the __path__ attribute contains both paths
        expected = [
            str(real_tmpdir / "site-pkgs" / "pkg1" / "pkg2"),
            str(real_tmpdir / "site-pkgs2" / "pkg1" / "pkg2"),
        ]
        assert pkg1.pkg2.__path__ == expected

    @issue591
    def test_path_order(self, symlinked_tmpdir):
        """
        Test that if multiple versions of the same namespace package subpackage
        are on different sys.path entries, that only the one earliest on
        sys.path is imported, and that the namespace package's __path__ is in
        the correct order.

        Regression test for https://github.com/pypa/setuptools/issues/207
        """

        tmpdir = symlinked_tmpdir
        site_dirs = (
            tmpdir / "site-pkgs",
            tmpdir / "site-pkgs2",
            tmpdir / "site-pkgs3",
        )

        vers_str = "__version__ = %r"

        for number, site in enumerate(site_dirs, 1):
            if number > 1:
                sys.path.append(str(site))
            nspkg = site / 'nspkg'
            subpkg = nspkg / 'subpkg'
            subpkg.ensure_dir()
            (nspkg / '__init__.py').write_text(self.ns_str, encoding='utf-8')
            (subpkg / '__init__.py').write_text(vers_str % number, encoding='utf-8')

        with pytest.warns(DeprecationWarning, match="pkg_resources.declare_namespace"):
            import nspkg.subpkg
            import nspkg
        expected = [str(site.realpath() / 'nspkg') for site in site_dirs]
        assert nspkg.__path__ == expected
        assert nspkg.subpkg.__version__ == 1
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pkg_resources/tests/test_working_set.py0000644000175100001730000002052314467657412023435 0ustar00runnerdockerimport inspect
import re
import textwrap
import functools

import pytest

import pkg_resources

from .test_resources import Metadata


def strip_comments(s):
    return '\n'.join(
        line
        for line in s.split('\n')
        if line.strip() and not line.strip().startswith('#')
    )


def parse_distributions(s):
    '''
    Parse a series of distribution specs of the form:
    {project_name}-{version}
       [optional, indented requirements specification]

    Example:

        foo-0.2
        bar-1.0
          foo>=3.0
          [feature]
          baz

    yield 2 distributions:
        - project_name=foo, version=0.2
        - project_name=bar, version=1.0,
          requires=['foo>=3.0', 'baz; extra=="feature"']
    '''
    s = s.strip()
    for spec in re.split(r'\n(?=[^\s])', s):
        if not spec:
            continue
        fields = spec.split('\n', 1)
        assert 1 <= len(fields) <= 2
        name, version = fields.pop(0).rsplit('-', 1)
        if fields:
            requires = textwrap.dedent(fields.pop(0))
            metadata = Metadata(('requires.txt', requires))
        else:
            metadata = None
        dist = pkg_resources.Distribution(
            project_name=name, version=version, metadata=metadata
        )
        yield dist


class FakeInstaller:
    def __init__(self, installable_dists):
        self._installable_dists = installable_dists

    def __call__(self, req):
        return next(
            iter(filter(lambda dist: dist in req, self._installable_dists)), None
        )


def parametrize_test_working_set_resolve(*test_list):
    idlist = []
    argvalues = []
    for test in test_list:
        (
            name,
            installed_dists,
            installable_dists,
            requirements,
            expected1,
            expected2,
        ) = [
            strip_comments(s.lstrip())
            for s in textwrap.dedent(test).lstrip().split('\n\n', 5)
        ]
        installed_dists = list(parse_distributions(installed_dists))
        installable_dists = list(parse_distributions(installable_dists))
        requirements = list(pkg_resources.parse_requirements(requirements))
        for id_, replace_conflicting, expected in (
            (name, False, expected1),
            (name + '_replace_conflicting', True, expected2),
        ):
            idlist.append(id_)
            expected = strip_comments(expected.strip())
            if re.match(r'\w+$', expected):
                expected = getattr(pkg_resources, expected)
                assert issubclass(expected, Exception)
            else:
                expected = list(parse_distributions(expected))
            argvalues.append(
                pytest.param(
                    installed_dists,
                    installable_dists,
                    requirements,
                    replace_conflicting,
                    expected,
                )
            )
    return pytest.mark.parametrize(
        'installed_dists,installable_dists,'
        'requirements,replace_conflicting,'
        'resolved_dists_or_exception',
        argvalues,
        ids=idlist,
    )


@parametrize_test_working_set_resolve(
    '''
    # id
    noop

    # installed

    # installable

    # wanted

    # resolved

    # resolved [replace conflicting]
    ''',
    '''
    # id
    already_installed

    # installed
    foo-3.0

    # installable

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    foo-3.0

    # resolved [replace conflicting]
    foo-3.0
    ''',
    '''
    # id
    installable_not_installed

    # installed

    # installable
    foo-3.0
    foo-4.0

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    foo-3.0

    # resolved [replace conflicting]
    foo-3.0
    ''',
    '''
    # id
    not_installable

    # installed

    # installable

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    DistributionNotFound

    # resolved [replace conflicting]
    DistributionNotFound
    ''',
    '''
    # id
    no_matching_version

    # installed

    # installable
    foo-3.1

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    DistributionNotFound

    # resolved [replace conflicting]
    DistributionNotFound
    ''',
    '''
    # id
    installable_with_installed_conflict

    # installed
    foo-3.1

    # installable
    foo-3.5

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    foo-3.5
    ''',
    '''
    # id
    not_installable_with_installed_conflict

    # installed
    foo-3.1

    # installable

    # wanted
    foo>=2.1,!=3.1,<4

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    DistributionNotFound
    ''',
    '''
    # id
    installed_with_installed_require

    # installed
    foo-3.9
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',
    '''
    # id
    installed_with_conflicting_installed_require

    # installed
    foo-5
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable

    # wanted
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    DistributionNotFound
    ''',
    '''
    # id
    installed_with_installable_conflicting_require

    # installed
    foo-5
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable
    foo-2.9

    # wanted
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    baz-0.1
    foo-2.9
    ''',
    '''
    # id
    installed_with_installable_require

    # installed
    baz-0.1
        foo>=2.1,!=3.1,<4

    # installable
    foo-3.9

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',
    '''
    # id
    installable_with_installed_require

    # installed
    foo-3.9

    # installable
    baz-0.1
        foo>=2.1,!=3.1,<4

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',
    '''
    # id
    installable_with_installable_require

    # installed

    # installable
    foo-3.9
    baz-0.1
        foo>=2.1,!=3.1,<4

    # wanted
    baz

    # resolved
    foo-3.9
    baz-0.1

    # resolved [replace conflicting]
    foo-3.9
    baz-0.1
    ''',
    '''
    # id
    installable_with_conflicting_installable_require

    # installed
    foo-5

    # installable
    foo-2.9
    baz-0.1
        foo>=2.1,!=3.1,<4

    # wanted
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    baz-0.1
    foo-2.9
    ''',
    '''
    # id
    conflicting_installables

    # installed

    # installable
    foo-2.9
    foo-5.0

    # wanted
    foo>=2.1,!=3.1,<4
    foo>=4

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    VersionConflict
    ''',
    '''
    # id
    installables_with_conflicting_requires

    # installed

    # installable
    foo-2.9
        dep==1.0
    baz-5.0
        dep==2.0
    dep-1.0
    dep-2.0

    # wanted
    foo
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    VersionConflict
    ''',
    '''
    # id
    installables_with_conflicting_nested_requires

    # installed

    # installable
    foo-2.9
        dep1
    dep1-1.0
        subdep<1.0
    baz-5.0
        dep2
    dep2-1.0
        subdep>1.0
    subdep-0.9
    subdep-1.1

    # wanted
    foo
    baz

    # resolved
    VersionConflict

    # resolved [replace conflicting]
    VersionConflict
    ''',
    '''
    # id
    wanted_normalized_name_installed_canonical

    # installed
    foo.bar-3.6

    # installable

    # wanted
    foo-bar==3.6

    # resolved
    foo.bar-3.6

    # resolved [replace conflicting]
    foo.bar-3.6
    ''',
)
def test_working_set_resolve(
    installed_dists,
    installable_dists,
    requirements,
    replace_conflicting,
    resolved_dists_or_exception,
):
    ws = pkg_resources.WorkingSet([])
    list(map(ws.add, installed_dists))
    resolve_call = functools.partial(
        ws.resolve,
        requirements,
        installer=FakeInstaller(installable_dists),
        replace_conflicting=replace_conflicting,
    )
    if inspect.isclass(resolved_dists_or_exception):
        with pytest.raises(resolved_dists_or_exception):
            resolve_call()
    else:
        assert sorted(resolve_call()) == sorted(resolved_dists_or_exception)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pyproject.toml0000644000175100001730000000034214467657412016365 0ustar00runnerdocker[build-system]
requires = []
build-backend = "setuptools.build_meta"
backend-path = ["."]

[tool.black]
skip-string-normalization = true
extend_exclude = "_vendor"

[tool.setuptools_scm]

[tool.pytest-enabler.mypy]
# disabled
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/pytest.ini0000644000175100001730000000642314467657412015510 0ustar00runnerdocker[pytest]
norecursedirs=dist build .tox .eggs
addopts=
	--doctest-modules
	--doctest-glob=pkg_resources/api_tests.txt
	-r sxX
doctest_optionflags=ALLOW_UNICODE ELLIPSIS
filterwarnings=
	# Fail on warnings
	error

	## upstream

	# Ensure ResourceWarnings are emitted
	default::ResourceWarning

	# shopkeep/pytest-black#55
	ignore: is not using a cooperative constructor:pytest.PytestDeprecationWarning
	ignore:The \(fspath. py.path.local\) argument to BlackItem is deprecated.:pytest.PytestDeprecationWarning
	ignore:BlackItem is an Item subclass and should not be a collector:pytest.PytestWarning

	# shopkeep/pytest-black#67
	ignore:'encoding' argument not specified::pytest_black

	# realpython/pytest-mypy#152
	ignore:'encoding' argument not specified::pytest_mypy

	# python/cpython#100750
	ignore:'encoding' argument not specified::platform

	# pypa/build#615
	ignore:'encoding' argument not specified::build.env

	## end upstream

	# https://github.com/pypa/setuptools/issues/1823
	ignore:bdist_wininst command is deprecated
	# Suppress this error; unimportant for CI tests
	ignore:Extraction path is writable by group/others:UserWarning
	# Suppress weird RuntimeWarning.
	ignore:Parent module 'setuptools' not found while handling absolute import:RuntimeWarning
	# Suppress use of bytes for filenames on Windows until fixed #2016
	ignore:The Windows bytes API has been deprecated:DeprecationWarning

	# https://github.com/pypa/setuptools/issues/2823
	ignore:setuptools.installer and fetch_build_eggs are deprecated.

	# https://github.com/pypa/setuptools/issues/917
	ignore:setup.py install is deprecated.
	ignore:easy_install command is deprecated.

	# https://github.com/pypa/setuptools/issues/2497
	ignore:.* is an invalid version and will not be supported::pkg_resources

	# https://github.com/pypa/setuptools/pull/2865#issuecomment-965700112
	# ideally would apply to Python 3.10+ when
	# SETUPTOOLS_USE_DISTUTILS=stdlib but for
	# https://github.com/pytest-dev/pytest/discussions/9296
	ignore:The distutils.sysconfig module is deprecated, use sysconfig instead
	ignore:The distutils package is deprecated.*

	# Workaround for pypa/setuptools#2868
	# ideally would apply to PyPy only but for
	# https://github.com/pytest-dev/pytest/discussions/9296
	ignore:Distutils was imported before setuptools
	ignore:Setuptools is replacing distutils

	# suppress warnings in deprecated msvc compilers
	ignore:(bcpp|msvc9?)compiler is deprecated

	ignore::setuptools.command.editable_wheel.InformationOnly

	# https://github.com/pypa/setuptools/issues/3655
	ignore:The --rsyncdir command line argument and rsyncdirs config variable are deprecated.:DeprecationWarning

	# Workarounds for pypa/setuptools#3810
	# Can't use EncodingWarning as it doesn't exist on Python 3.9
	default:'encoding' argument not specified
	default:UTF-8 Mode affects locale.getpreferredencoding().

	# Avoid errors when testing pkg_resources.declare_namespace
	ignore:.*pkg_resources\.declare_namespace.*:DeprecationWarning

	# suppress known deprecation
	ignore:pkg_resources is deprecated:DeprecationWarning

	# Dependencies might not have been updated yet
	default:onerror argument is deprecated, use onexc instead

	# Ignore warnings about experimental features
	ignore:..tool\.distutils.. in .pyproject\.toml. is still .experimental.*
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5595517
setuptools-68.1.2/setup.cfg0000644000175100001730000001166514467657444015311 0ustar00runnerdocker[metadata]
name = setuptools
version = 68.1.2
author = Python Packaging Authority
author_email = distutils-sig@python.org
description = Easily download, build, install, upgrade, and uninstall Python packages
long_description = file:README.rst
url = https://github.com/pypa/setuptools
classifiers = 
	Development Status :: 5 - Production/Stable
	Intended Audience :: Developers
	License :: OSI Approved :: MIT License
	Programming Language :: Python :: 3
	Programming Language :: Python :: 3 :: Only
	Topic :: Software Development :: Libraries :: Python Modules
	Topic :: System :: Archiving :: Packaging
	Topic :: System :: Systems Administration
	Topic :: Utilities
keywords = CPAN PyPI distutils eggs package management
project_urls = 
	Documentation = https://setuptools.pypa.io/
	Changelog = https://setuptools.pypa.io/en/stable/history.html

[options]
packages = find_namespace:
python_requires = >=3.8
install_requires = 

[options.packages.find]
exclude = 
	build*
	dist*
	docs*
	tests*
	*.tests
	*.tests.*
	tools*
	debian*
	launcher*
	newsfragments*

[options.extras_require]
testing = 
	pytest >= 6
	pytest-checkdocs >= 2.4
	pytest-black >= 0.3.7; \
	python_implementation != "PyPy"
	pytest-cov; \
	python_implementation != "PyPy"
	pytest-mypy >= 0.9.1; \
	python_implementation != "PyPy"
	pytest-enabler >= 2.2
	pytest-ruff; sys_platform != "cygwin"
	
	flake8-2020
	virtualenv>=13.0.0
	wheel
	pip>=19.1 # For proper file:// URLs support.
	jaraco.envs>=2.2
	pytest-xdist
	jaraco.path>=3.2.0
	build[virtualenv]
	filelock>=3.4.0
	ini2toml[lite]>=0.9
	tomli-w>=1.0.0
	pytest-timeout
	pytest-perf; \
	sys_platform != "cygwin"
	jaraco.develop >= 7.21; python_version >= "3.9" and sys_platform != "cygwin"
testing-integration = 
	pytest
	pytest-xdist
	pytest-enabler
	virtualenv>=13.0.0
	tomli
	wheel
	jaraco.path>=3.2.0
	jaraco.envs>=2.2
	build[virtualenv]
	filelock>=3.4.0
docs = 
	sphinx >= 3.5,<=7.1.2  # workaround, see comments in pypa/setuptools#4020
	jaraco.packaging >= 9.3
	rst.linker >= 1.9
	furo
	sphinx-lint
	
	jaraco.tidelift >= 1.4
	
	pygments-github-lexers==0.0.5
	sphinx-favicon
	sphinx-inline-tabs
	sphinx-reredirects
	sphinxcontrib-towncrier
	sphinx-notfound-page == 0.8.3
	sphinx-hoverxref < 2
ssl = 
certs = 

[options.entry_points]
distutils.commands = 
	alias = setuptools.command.alias:alias
	bdist_egg = setuptools.command.bdist_egg:bdist_egg
	bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
	build = setuptools.command.build:build
	build_clib = setuptools.command.build_clib:build_clib
	build_ext = setuptools.command.build_ext:build_ext
	build_py = setuptools.command.build_py:build_py
	develop = setuptools.command.develop:develop
	dist_info = setuptools.command.dist_info:dist_info
	easy_install = setuptools.command.easy_install:easy_install
	editable_wheel = setuptools.command.editable_wheel:editable_wheel
	egg_info = setuptools.command.egg_info:egg_info
	install = setuptools.command.install:install
	install_egg_info = setuptools.command.install_egg_info:install_egg_info
	install_lib = setuptools.command.install_lib:install_lib
	install_scripts = setuptools.command.install_scripts:install_scripts
	rotate = setuptools.command.rotate:rotate
	saveopts = setuptools.command.saveopts:saveopts
	sdist = setuptools.command.sdist:sdist
	setopt = setuptools.command.setopt:setopt
	test = setuptools.command.test:test
	upload_docs = setuptools.command.upload_docs:upload_docs
setuptools.finalize_distribution_options = 
	parent_finalize = setuptools.dist:_Distribution.finalize_options
	keywords = setuptools.dist:Distribution._finalize_setup_keywords
distutils.setup_keywords = 
	eager_resources = setuptools.dist:assert_string_list
	namespace_packages = setuptools.dist:check_nsp
	extras_require = setuptools.dist:check_extras
	install_requires = setuptools.dist:check_requirements
	tests_require = setuptools.dist:check_requirements
	setup_requires = setuptools.dist:check_requirements
	python_requires = setuptools.dist:check_specifier
	entry_points = setuptools.dist:check_entry_points
	test_suite = setuptools.dist:check_test_suite
	zip_safe = setuptools.dist:assert_bool
	package_data = setuptools.dist:check_package_data
	exclude_package_data = setuptools.dist:check_package_data
	include_package_data = setuptools.dist:assert_bool
	packages = setuptools.dist:check_packages
	dependency_links = setuptools.dist:assert_string_list
	test_loader = setuptools.dist:check_importable
	test_runner = setuptools.dist:check_importable
	use_2to3 = setuptools.dist:invalid_unless_false
egg_info.writers = 
	PKG-INFO = setuptools.command.egg_info:write_pkg_info
	requires.txt = setuptools.command.egg_info:write_requirements
	entry_points.txt = setuptools.command.egg_info:write_entries
	eager_resources.txt = setuptools.command.egg_info:overwrite_arg
	namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
	top_level.txt = setuptools.command.egg_info:write_toplevel_names
	dependency_links.txt = setuptools.command.egg_info:overwrite_arg

[egg_info]
tag_build = 
tag_date = 0

[sdist]
formats = zip

././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setup.py0000755000175100001730000000516314467657412015174 0ustar00runnerdocker#!/usr/bin/env python

import os
import sys
import textwrap

import setuptools
from setuptools.command.install import install

here = os.path.dirname(__file__)


package_data = dict(
    setuptools=['script (dev).tmpl', 'script.tmpl', 'site-patch.py'],
)

force_windows_specific_files = os.environ.get(
    "SETUPTOOLS_INSTALL_WINDOWS_SPECIFIC_FILES", "1"
).lower() not in ("", "0", "false", "no")

include_windows_files = sys.platform == 'win32' or force_windows_specific_files

if include_windows_files:
    package_data.setdefault('setuptools', []).extend(['*.exe'])
    package_data.setdefault('setuptools.command', []).extend(['*.xml'])


def pypi_link(pkg_filename):
    """
    Given the filename, including md5 fragment, construct the
    dependency link for PyPI.
    """
    root = 'https://files.pythonhosted.org/packages/source'
    name, sep, rest = pkg_filename.partition('-')
    parts = root, name[0], name, pkg_filename
    return '/'.join(parts)


class install_with_pth(install):
    """
    Custom install command to install a .pth file for distutils patching.

    This hack is necessary because there's no standard way to install behavior
    on startup (and it's debatable if there should be one). This hack (ab)uses
    the `extra_path` behavior in Setuptools to install a `.pth` file with
    implicit behavior on startup to give higher precedence to the local version
    of `distutils` over the version from the standard library.

    Please do not replicate this behavior.
    """

    _pth_name = 'distutils-precedence'
    _pth_contents = (
        textwrap.dedent(
            """
        import os
        var = 'SETUPTOOLS_USE_DISTUTILS'
        enabled = os.environ.get(var, 'local') == 'local'
        enabled and __import__('_distutils_hack').add_shim()
        """
        )
        .lstrip()
        .replace('\n', '; ')
    )

    def initialize_options(self):
        install.initialize_options(self)
        self.extra_path = self._pth_name, self._pth_contents

    def finalize_options(self):
        install.finalize_options(self)
        self._restore_install_lib()

    def _restore_install_lib(self):
        """
        Undo secondary effect of `extra_path` adding to `install_lib`
        """
        suffix = os.path.relpath(self.install_lib, self.install_libbase)

        if suffix.strip() == self._pth_contents.strip():
            self.install_lib = self.install_libbase


setup_params = dict(
    cmdclass={'install': install_with_pth},
    package_data=package_data,
)

if __name__ == '__main__':
    # allow setup.py to run from another directory
    here and os.chdir(here)
    dist = setuptools.setup(**setup_params)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5075488
setuptools-68.1.2/setuptools/0000755000175100001730000000000014467657444015700 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/__init__.py0000644000175100001730000002205214467657412020005 0ustar00runnerdocker"""Extensions to the 'distutils' for large or complex distributions"""

import functools
import os
import re

import _distutils_hack.override  # noqa: F401

import distutils.core
from distutils.errors import DistutilsOptionError
from distutils.util import convert_path as _convert_path

from .warnings import SetuptoolsDeprecationWarning

import setuptools.version
from setuptools.extension import Extension
from setuptools.dist import Distribution
from setuptools.depends import Require
from setuptools.discovery import PackageFinder, PEP420PackageFinder
from . import monkey
from . import logging


__all__ = [
    'setup',
    'Distribution',
    'Command',
    'Extension',
    'Require',
    'SetuptoolsDeprecationWarning',
    'find_packages',
    'find_namespace_packages',
]

__version__ = setuptools.version.__version__

bootstrap_install_from = None


find_packages = PackageFinder.find
find_namespace_packages = PEP420PackageFinder.find


def _install_setup_requires(attrs):
    # Note: do not use `setuptools.Distribution` directly, as
    # our PEP 517 backend patch `distutils.core.Distribution`.
    class MinimalDistribution(distutils.core.Distribution):
        """
        A minimal version of a distribution for supporting the
        fetch_build_eggs interface.
        """

        def __init__(self, attrs):
            _incl = 'dependency_links', 'setup_requires'
            filtered = {k: attrs[k] for k in set(_incl) & set(attrs)}
            super().__init__(filtered)
            # Prevent accidentally triggering discovery with incomplete set of attrs
            self.set_defaults._disable()

        def _get_project_config_files(self, filenames=None):
            """Ignore ``pyproject.toml``, they are not related to setup_requires"""
            try:
                cfg, toml = super()._split_standard_project_metadata(filenames)
                return cfg, ()
            except Exception:
                return filenames, ()

        def finalize_options(self):
            """
            Disable finalize_options to avoid building the working set.
            Ref #2158.
            """

    dist = MinimalDistribution(attrs)

    # Honor setup.cfg's options.
    dist.parse_config_files(ignore_option_errors=True)
    if dist.setup_requires:
        _fetch_build_eggs(dist)


def _fetch_build_eggs(dist):
    try:
        dist.fetch_build_eggs(dist.setup_requires)
    except Exception as ex:
        msg = """
        It is possible a package already installed in your system
        contains an version that is invalid according to PEP 440.
        You can try `pip install --use-pep517` as a workaround for this problem,
        or rely on a new virtual environment.

        If the problem refers to a package that is not installed yet,
        please contact that package's maintainers or distributors.
        """
        if "InvalidVersion" in ex.__class__.__name__:
            if hasattr(ex, "add_note"):
                ex.add_note(msg)  # PEP 678
            else:
                dist.announce(f"\n{msg}\n")
        raise


def setup(**attrs):
    # Make sure we have any requirements needed to interpret 'attrs'.
    logging.configure()
    _install_setup_requires(attrs)
    return distutils.core.setup(**attrs)


setup.__doc__ = distutils.core.setup.__doc__


_Command = monkey.get_unpatched(distutils.core.Command)


class Command(_Command):
    """
    Setuptools internal actions are organized using a *command design pattern*.
    This means that each action (or group of closely related actions) executed during
    the build should be implemented as a ``Command`` subclass.

    These commands are abstractions and do not necessarily correspond to a command that
    can (or should) be executed via a terminal, in a CLI fashion (although historically
    they would).

    When creating a new command from scratch, custom defined classes **SHOULD** inherit
    from ``setuptools.Command`` and implement a few mandatory methods.
    Between these mandatory methods, are listed:

    .. method:: initialize_options(self)

        Set or (reset) all options/attributes/caches used by the command
        to their default values. Note that these values may be overwritten during
        the build.

    .. method:: finalize_options(self)

        Set final values for all options/attributes used by the command.
        Most of the time, each option/attribute/cache should only be set if it does not
        have any value yet (e.g. ``if self.attr is None: self.attr = val``).

    .. method:: run(self)

        Execute the actions intended by the command.
        (Side effects **SHOULD** only take place when ``run`` is executed,
        for example, creating new files or writing to the terminal output).

    A useful analogy for command classes is to think of them as subroutines with local
    variables called "options".  The options are "declared" in ``initialize_options()``
    and "defined" (given their final values, aka "finalized") in ``finalize_options()``,
    both of which must be defined by every command class. The "body" of the subroutine,
    (where it does all the work) is the ``run()`` method.
    Between ``initialize_options()`` and ``finalize_options()``, ``setuptools`` may set
    the values for options/attributes based on user's input (or circumstance),
    which means that the implementation should be careful to not overwrite values in
    ``finalize_options`` unless necessary.

    Please note that other commands (or other parts of setuptools) may also overwrite
    the values of the command's options/attributes multiple times during the build
    process.
    Therefore it is important to consistently implement ``initialize_options()`` and
    ``finalize_options()``. For example, all derived attributes (or attributes that
    depend on the value of other attributes) **SHOULD** be recomputed in
    ``finalize_options``.

    When overwriting existing commands, custom defined classes **MUST** abide by the
    same APIs implemented by the original class. They also **SHOULD** inherit from the
    original class.
    """

    command_consumes_arguments = False

    def __init__(self, dist, **kw):
        """
        Construct the command for dist, updating
        vars(self) with any keyword parameters.
        """
        super().__init__(dist)
        vars(self).update(kw)

    def _ensure_stringlike(self, option, what, default=None):
        val = getattr(self, option)
        if val is None:
            setattr(self, option, default)
            return default
        elif not isinstance(val, str):
            raise DistutilsOptionError(
                "'%s' must be a %s (got `%s`)" % (option, what, val)
            )
        return val

    def ensure_string_list(self, option):
        r"""Ensure that 'option' is a list of strings.  If 'option' is
        currently a string, we split it either on /,\s*/ or /\s+/, so
        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
        ["foo", "bar", "baz"].

        ..
           TODO: This method seems to be similar to the one in ``distutils.cmd``
           Probably it is just here for backward compatibility with old Python versions?

        :meta private:
        """
        val = getattr(self, option)
        if val is None:
            return
        elif isinstance(val, str):
            setattr(self, option, re.split(r',\s*|\s+', val))
        else:
            if isinstance(val, list):
                ok = all(isinstance(v, str) for v in val)
            else:
                ok = False
            if not ok:
                raise DistutilsOptionError(
                    "'%s' must be a list of strings (got %r)" % (option, val)
                )

    def reinitialize_command(self, command, reinit_subcommands=0, **kw):
        cmd = _Command.reinitialize_command(self, command, reinit_subcommands)
        vars(cmd).update(kw)
        return cmd


def _find_all_simple(path):
    """
    Find all files under 'path'
    """
    results = (
        os.path.join(base, file)
        for base, dirs, files in os.walk(path, followlinks=True)
        for file in files
    )
    return filter(os.path.isfile, results)


def findall(dir=os.curdir):
    """
    Find all files under 'dir' and return the list of full filenames.
    Unless dir is '.', return full filenames with dir prepended.
    """
    files = _find_all_simple(dir)
    if dir == os.curdir:
        make_rel = functools.partial(os.path.relpath, start=dir)
        files = map(make_rel, files)
    return list(files)


@functools.wraps(_convert_path)
def convert_path(pathname):
    SetuptoolsDeprecationWarning.emit(
        "Access to implementation detail",
        """
        The function `convert_path` is not provided by setuptools itself,
        and therefore not part of the public API.

        Its direct usage by 3rd-party packages is considered improper and the function
        may be removed in the future.
        """,
        due_date=(2023, 12, 13),  # initial deprecation 2022-03-25, see #3201
    )
    return _convert_path(pathname)


class sic(str):
    """Treat this string as-is (https://en.wikipedia.org/wiki/Sic)"""


# Apply monkey patches
monkey.patch_all()
././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.511549
setuptools-68.1.2/setuptools/_distutils/0000755000175100001730000000000014467657444020063 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/__init__.py0000644000175100001730000000054714467657412022175 0ustar00runnerdockerimport sys
import importlib

__version__, _, _ = sys.version.partition(' ')


try:
    # Allow Debian and pkgsrc (only) to customize system
    # behavior. Ref pypa/distutils#2 and pypa/distutils#16.
    # This hook is deprecated and no other environments
    # should use it.
    importlib.import_module('_distutils_system_mod')
except ImportError:
    pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/_collections.py0000644000175100001730000001226414467657412023112 0ustar00runnerdockerimport collections
import functools
import itertools
import operator


# from jaraco.collections 3.5.1
class DictStack(list, collections.abc.Mapping):
    """
    A stack of dictionaries that behaves as a view on those dictionaries,
    giving preference to the last.

    >>> stack = DictStack([dict(a=1, c=2), dict(b=2, a=2)])
    >>> stack['a']
    2
    >>> stack['b']
    2
    >>> stack['c']
    2
    >>> len(stack)
    3
    >>> stack.push(dict(a=3))
    >>> stack['a']
    3
    >>> set(stack.keys()) == set(['a', 'b', 'c'])
    True
    >>> set(stack.items()) == set([('a', 3), ('b', 2), ('c', 2)])
    True
    >>> dict(**stack) == dict(stack) == dict(a=3, c=2, b=2)
    True
    >>> d = stack.pop()
    >>> stack['a']
    2
    >>> d = stack.pop()
    >>> stack['a']
    1
    >>> stack.get('b', None)
    >>> 'c' in stack
    True
    """

    def __iter__(self):
        dicts = list.__iter__(self)
        return iter(set(itertools.chain.from_iterable(c.keys() for c in dicts)))

    def __getitem__(self, key):
        for scope in reversed(tuple(list.__iter__(self))):
            if key in scope:
                return scope[key]
        raise KeyError(key)

    push = list.append

    def __contains__(self, other):
        return collections.abc.Mapping.__contains__(self, other)

    def __len__(self):
        return len(list(iter(self)))


# from jaraco.collections 3.7
class RangeMap(dict):
    """
    A dictionary-like object that uses the keys as bounds for a range.
    Inclusion of the value for that range is determined by the
    key_match_comparator, which defaults to less-than-or-equal.
    A value is returned for a key if it is the first key that matches in
    the sorted list of keys.

    One may supply keyword parameters to be passed to the sort function used
    to sort keys (i.e. key, reverse) as sort_params.

    Let's create a map that maps 1-3 -> 'a', 4-6 -> 'b'

    >>> r = RangeMap({3: 'a', 6: 'b'})  # boy, that was easy
    >>> r[1], r[2], r[3], r[4], r[5], r[6]
    ('a', 'a', 'a', 'b', 'b', 'b')

    Even float values should work so long as the comparison operator
    supports it.

    >>> r[4.5]
    'b'

    But you'll notice that the way rangemap is defined, it must be open-ended
    on one side.

    >>> r[0]
    'a'
    >>> r[-1]
    'a'

    One can close the open-end of the RangeMap by using undefined_value

    >>> r = RangeMap({0: RangeMap.undefined_value, 3: 'a', 6: 'b'})
    >>> r[0]
    Traceback (most recent call last):
    ...
    KeyError: 0

    One can get the first or last elements in the range by using RangeMap.Item

    >>> last_item = RangeMap.Item(-1)
    >>> r[last_item]
    'b'

    .last_item is a shortcut for Item(-1)

    >>> r[RangeMap.last_item]
    'b'

    Sometimes it's useful to find the bounds for a RangeMap

    >>> r.bounds()
    (0, 6)

    RangeMap supports .get(key, default)

    >>> r.get(0, 'not found')
    'not found'

    >>> r.get(7, 'not found')
    'not found'

    One often wishes to define the ranges by their left-most values,
    which requires use of sort params and a key_match_comparator.

    >>> r = RangeMap({1: 'a', 4: 'b'},
    ...     sort_params=dict(reverse=True),
    ...     key_match_comparator=operator.ge)
    >>> r[1], r[2], r[3], r[4], r[5], r[6]
    ('a', 'a', 'a', 'b', 'b', 'b')

    That wasn't nearly as easy as before, so an alternate constructor
    is provided:

    >>> r = RangeMap.left({1: 'a', 4: 'b', 7: RangeMap.undefined_value})
    >>> r[1], r[2], r[3], r[4], r[5], r[6]
    ('a', 'a', 'a', 'b', 'b', 'b')

    """

    def __init__(self, source, sort_params={}, key_match_comparator=operator.le):
        dict.__init__(self, source)
        self.sort_params = sort_params
        self.match = key_match_comparator

    @classmethod
    def left(cls, source):
        return cls(
            source, sort_params=dict(reverse=True), key_match_comparator=operator.ge
        )

    def __getitem__(self, item):
        sorted_keys = sorted(self.keys(), **self.sort_params)
        if isinstance(item, RangeMap.Item):
            result = self.__getitem__(sorted_keys[item])
        else:
            key = self._find_first_match_(sorted_keys, item)
            result = dict.__getitem__(self, key)
            if result is RangeMap.undefined_value:
                raise KeyError(key)
        return result

    def get(self, key, default=None):
        """
        Return the value for key if key is in the dictionary, else default.
        If default is not given, it defaults to None, so that this method
        never raises a KeyError.
        """
        try:
            return self[key]
        except KeyError:
            return default

    def _find_first_match_(self, keys, item):
        is_match = functools.partial(self.match, item)
        matches = list(filter(is_match, keys))
        if matches:
            return matches[0]
        raise KeyError(item)

    def bounds(self):
        sorted_keys = sorted(self.keys(), **self.sort_params)
        return (sorted_keys[RangeMap.first_item], sorted_keys[RangeMap.last_item])

    # some special values for the RangeMap
    undefined_value = type('RangeValueUndefined', (), {})()

    class Item(int):
        "RangeMap Item"

    first_item = Item(0)
    last_item = Item(-1)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/_functools.py0000644000175100001730000000063314467657412022605 0ustar00runnerdockerimport functools


# from jaraco.functools 3.5
def pass_none(func):
    """
    Wrap func so it's not called if its first param is None

    >>> print_text = pass_none(print)
    >>> print_text('text')
    text
    >>> print_text(None)
    """

    @functools.wraps(func)
    def wrapper(param, *args, **kwargs):
        if param is not None:
            return func(param, *args, **kwargs)

    return wrapper
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/_log.py0000644000175100001730000000005314467657412021346 0ustar00runnerdockerimport logging


log = logging.getLogger()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/_macos_compat.py0000644000175100001730000000035714467657412023241 0ustar00runnerdockerimport sys
import importlib


def bypass_compiler_fixup(cmd, args):
    return cmd


if sys.platform == 'darwin':
    compiler_fixup = importlib.import_module('_osx_support').compiler_fixup
else:
    compiler_fixup = bypass_compiler_fixup
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/_msvccompiler.py0000644000175100001730000004624014467657412023300 0ustar00runnerdocker"""distutils._msvccompiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for Microsoft Visual Studio 2015.

The module is compatible with VS 2015 and later. You can find legacy support
for older versions in distutils.msvc9compiler and distutils.msvccompiler.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)
# ported to VS 2005 and VS 2008 by Christian Heimes
# ported to VS 2015 by Steve Dower

import os
import subprocess
import contextlib
import warnings
import unittest.mock as mock

with contextlib.suppress(ImportError):
    import winreg

from .errors import (
    DistutilsExecError,
    DistutilsPlatformError,
    CompileError,
    LibError,
    LinkError,
)
from .ccompiler import CCompiler, gen_lib_options
from ._log import log
from .util import get_platform

from itertools import count


def _find_vc2015():
    try:
        key = winreg.OpenKeyEx(
            winreg.HKEY_LOCAL_MACHINE,
            r"Software\Microsoft\VisualStudio\SxS\VC7",
            access=winreg.KEY_READ | winreg.KEY_WOW64_32KEY,
        )
    except OSError:
        log.debug("Visual C++ is not registered")
        return None, None

    best_version = 0
    best_dir = None
    with key:
        for i in count():
            try:
                v, vc_dir, vt = winreg.EnumValue(key, i)
            except OSError:
                break
            if v and vt == winreg.REG_SZ and os.path.isdir(vc_dir):
                try:
                    version = int(float(v))
                except (ValueError, TypeError):
                    continue
                if version >= 14 and version > best_version:
                    best_version, best_dir = version, vc_dir
    return best_version, best_dir


def _find_vc2017():
    """Returns "15, path" based on the result of invoking vswhere.exe
    If no install is found, returns "None, None"

    The version is returned to avoid unnecessarily changing the function
    result. It may be ignored when the path is not None.

    If vswhere.exe is not available, by definition, VS 2017 is not
    installed.
    """
    root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
    if not root:
        return None, None

    try:
        path = subprocess.check_output(
            [
                os.path.join(
                    root, "Microsoft Visual Studio", "Installer", "vswhere.exe"
                ),
                "-latest",
                "-prerelease",
                "-requires",
                "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
                "-property",
                "installationPath",
                "-products",
                "*",
            ],
            encoding="mbcs",
            errors="strict",
        ).strip()
    except (subprocess.CalledProcessError, OSError, UnicodeDecodeError):
        return None, None

    path = os.path.join(path, "VC", "Auxiliary", "Build")
    if os.path.isdir(path):
        return 15, path

    return None, None


PLAT_SPEC_TO_RUNTIME = {
    'x86': 'x86',
    'x86_amd64': 'x64',
    'x86_arm': 'arm',
    'x86_arm64': 'arm64',
}


def _find_vcvarsall(plat_spec):
    # bpo-38597: Removed vcruntime return value
    _, best_dir = _find_vc2017()

    if not best_dir:
        best_version, best_dir = _find_vc2015()

    if not best_dir:
        log.debug("No suitable Visual C++ version found")
        return None, None

    vcvarsall = os.path.join(best_dir, "vcvarsall.bat")
    if not os.path.isfile(vcvarsall):
        log.debug("%s cannot be found", vcvarsall)
        return None, None

    return vcvarsall, None


def _get_vc_env(plat_spec):
    if os.getenv("DISTUTILS_USE_SDK"):
        return {key.lower(): value for key, value in os.environ.items()}

    vcvarsall, _ = _find_vcvarsall(plat_spec)
    if not vcvarsall:
        raise DistutilsPlatformError("Unable to find vcvarsall.bat")

    try:
        out = subprocess.check_output(
            f'cmd /u /c "{vcvarsall}" {plat_spec} && set',
            stderr=subprocess.STDOUT,
        ).decode('utf-16le', errors='replace')
    except subprocess.CalledProcessError as exc:
        log.error(exc.output)
        raise DistutilsPlatformError(f"Error executing {exc.cmd}")

    env = {
        key.lower(): value
        for key, _, value in (line.partition('=') for line in out.splitlines())
        if key and value
    }

    return env


def _find_exe(exe, paths=None):
    """Return path to an MSVC executable program.

    Tries to find the program in several places: first, one of the
    MSVC program search paths from the registry; next, the directories
    in the PATH environment variable.  If any of those work, return an
    absolute path that is known to exist.  If none of them work, just
    return the original program name, 'exe'.
    """
    if not paths:
        paths = os.getenv('path').split(os.pathsep)
    for p in paths:
        fn = os.path.join(os.path.abspath(p), exe)
        if os.path.isfile(fn):
            return fn
    return exe


# A map keyed by get_platform() return values to values accepted by
# 'vcvarsall.bat'. Always cross-compile from x86 to work with the
# lighter-weight MSVC installs that do not include native 64-bit tools.
PLAT_TO_VCVARS = {
    'win32': 'x86',
    'win-amd64': 'x86_amd64',
    'win-arm32': 'x86_arm',
    'win-arm64': 'x86_arm64',
}


class MSVCCompiler(CCompiler):
    """Concrete class that implements an interface to Microsoft Visual C++,
    as defined by the CCompiler abstract class."""

    compiler_type = 'msvc'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']
    _rc_extensions = ['.rc']
    _mc_extensions = ['.mc']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = _c_extensions + _cpp_extensions + _rc_extensions + _mc_extensions
    res_extension = '.res'
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

    def __init__(self, verbose=0, dry_run=0, force=0):
        super().__init__(verbose, dry_run, force)
        # target platform (.plat_name is consistent with 'bdist')
        self.plat_name = None
        self.initialized = False

    @classmethod
    def _configure(cls, vc_env):
        """
        Set class-level include/lib dirs.
        """
        cls.include_dirs = cls._parse_path(vc_env.get('include', ''))
        cls.library_dirs = cls._parse_path(vc_env.get('lib', ''))

    @staticmethod
    def _parse_path(val):
        return [dir.rstrip(os.sep) for dir in val.split(os.pathsep) if dir]

    def initialize(self, plat_name=None):
        # multi-init means we would need to check platform same each time...
        assert not self.initialized, "don't init multiple times"
        if plat_name is None:
            plat_name = get_platform()
        # sanity check for platforms to prevent obscure errors later.
        if plat_name not in PLAT_TO_VCVARS:
            raise DistutilsPlatformError(
                f"--plat-name must be one of {tuple(PLAT_TO_VCVARS)}"
            )

        # Get the vcvarsall.bat spec for the requested platform.
        plat_spec = PLAT_TO_VCVARS[plat_name]

        vc_env = _get_vc_env(plat_spec)
        if not vc_env:
            raise DistutilsPlatformError(
                "Unable to find a compatible " "Visual Studio installation."
            )
        self._configure(vc_env)

        self._paths = vc_env.get('path', '')
        paths = self._paths.split(os.pathsep)
        self.cc = _find_exe("cl.exe", paths)
        self.linker = _find_exe("link.exe", paths)
        self.lib = _find_exe("lib.exe", paths)
        self.rc = _find_exe("rc.exe", paths)  # resource compiler
        self.mc = _find_exe("mc.exe", paths)  # message compiler
        self.mt = _find_exe("mt.exe", paths)  # message compiler

        self.preprocess_options = None
        # bpo-38597: Always compile with dynamic linking
        # Future releases of Python 3.x will include all past
        # versions of vcruntime*.dll for compatibility.
        self.compile_options = ['/nologo', '/O2', '/W3', '/GL', '/DNDEBUG', '/MD']

        self.compile_options_debug = [
            '/nologo',
            '/Od',
            '/MDd',
            '/Zi',
            '/W3',
            '/D_DEBUG',
        ]

        ldflags = ['/nologo', '/INCREMENTAL:NO', '/LTCG']

        ldflags_debug = ['/nologo', '/INCREMENTAL:NO', '/LTCG', '/DEBUG:FULL']

        self.ldflags_exe = [*ldflags, '/MANIFEST:EMBED,ID=1']
        self.ldflags_exe_debug = [*ldflags_debug, '/MANIFEST:EMBED,ID=1']
        self.ldflags_shared = [
            *ldflags,
            '/DLL',
            '/MANIFEST:EMBED,ID=2',
            '/MANIFESTUAC:NO',
        ]
        self.ldflags_shared_debug = [
            *ldflags_debug,
            '/DLL',
            '/MANIFEST:EMBED,ID=2',
            '/MANIFESTUAC:NO',
        ]
        self.ldflags_static = [*ldflags]
        self.ldflags_static_debug = [*ldflags_debug]

        self._ldflags = {
            (CCompiler.EXECUTABLE, None): self.ldflags_exe,
            (CCompiler.EXECUTABLE, False): self.ldflags_exe,
            (CCompiler.EXECUTABLE, True): self.ldflags_exe_debug,
            (CCompiler.SHARED_OBJECT, None): self.ldflags_shared,
            (CCompiler.SHARED_OBJECT, False): self.ldflags_shared,
            (CCompiler.SHARED_OBJECT, True): self.ldflags_shared_debug,
            (CCompiler.SHARED_LIBRARY, None): self.ldflags_static,
            (CCompiler.SHARED_LIBRARY, False): self.ldflags_static,
            (CCompiler.SHARED_LIBRARY, True): self.ldflags_static_debug,
        }

        self.initialized = True

    # -- Worker methods ------------------------------------------------

    @property
    def out_extensions(self):
        return {
            **super().out_extensions,
            **{
                ext: self.res_extension
                for ext in self._rc_extensions + self._mc_extensions
            },
        }

    def compile(  # noqa: C901
        self,
        sources,
        output_dir=None,
        macros=None,
        include_dirs=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        depends=None,
    ):
        if not self.initialized:
            self.initialize()
        compile_info = self._setup_compile(
            output_dir, macros, include_dirs, sources, depends, extra_postargs
        )
        macros, objects, extra_postargs, pp_opts, build = compile_info

        compile_opts = extra_preargs or []
        compile_opts.append('/c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)

        add_cpp_opts = False

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            if debug:
                # pass the full pathname to MSVC in debug mode,
                # this allows the debugger to find the source file
                # without asking the user to browse for it
                src = os.path.abspath(src)

            if ext in self._c_extensions:
                input_opt = "/Tc" + src
            elif ext in self._cpp_extensions:
                input_opt = "/Tp" + src
                add_cpp_opts = True
            elif ext in self._rc_extensions:
                # compile .RC to .RES file
                input_opt = src
                output_opt = "/fo" + obj
                try:
                    self.spawn([self.rc] + pp_opts + [output_opt, input_opt])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            elif ext in self._mc_extensions:
                # Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.
                h_dir = os.path.dirname(src)
                rc_dir = os.path.dirname(obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn([self.mc, '-h', h_dir, '-r', rc_dir, src])
                    base, _ = os.path.splitext(os.path.basename(src))
                    rc_file = os.path.join(rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn([self.rc, "/fo" + obj, rc_file])

                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            else:
                # how to handle this file?
                raise CompileError(f"Don't know how to compile {src} to {obj}")

            args = [self.cc] + compile_opts + pp_opts
            if add_cpp_opts:
                args.append('/EHsc')
            args.extend((input_opt, "/Fo" + obj))
            args.extend(extra_postargs)

            try:
                self.spawn(args)
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects

    def create_static_lib(
        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
    ):
        if not self.initialized:
            self.initialize()
        objects, output_dir = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname, output_dir=output_dir)

        if self._need_link(objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass  # XXX what goes here?
            try:
                log.debug('Executing "%s" %s', self.lib, ' '.join(lib_args))
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def link(
        self,
        target_desc,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        if not self.initialized:
            self.initialize()
        objects, output_dir = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
        libraries, library_dirs, runtime_library_dirs = fixed_args

        if runtime_library_dirs:
            self.warn(
                "I don't know what to do with 'runtime_library_dirs': "
                + str(runtime_library_dirs)
            )

        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            ldflags = self._ldflags[target_desc, debug]

            export_opts = ["/EXPORT:" + sym for sym in (export_symbols or [])]

            ld_args = (
                ldflags + lib_opts + export_opts + objects + ['/OUT:' + output_filename]
            )

            # The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            build_temp = os.path.dirname(objects[0])
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename)
                )
                implib_file = os.path.join(build_temp, self.library_filename(dll_name))
                ld_args.append('/IMPLIB:' + implib_file)

            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            output_dir = os.path.dirname(os.path.abspath(output_filename))
            self.mkpath(output_dir)
            try:
                log.debug('Executing "%s" %s', self.linker, ' '.join(ld_args))
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def spawn(self, cmd):
        env = dict(os.environ, PATH=self._paths)
        with self._fallback_spawn(cmd, env) as fallback:
            return super().spawn(cmd, env=env)
        return fallback.value

    @contextlib.contextmanager
    def _fallback_spawn(self, cmd, env):
        """
        Discovered in pypa/distutils#15, some tools monkeypatch the compiler,
        so the 'env' kwarg causes a TypeError. Detect this condition and
        restore the legacy, unsafe behavior.
        """
        bag = type('Bag', (), {})()
        try:
            yield bag
        except TypeError as exc:
            if "unexpected keyword argument 'env'" not in str(exc):
                raise
        else:
            return
        warnings.warn("Fallback spawn triggered. Please update distutils monkeypatch.")
        with mock.patch.dict('os.environ', env):
            bag.value = super().spawn(cmd)

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "/LIBPATH:" + dir

    def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(
            "don't know how to set runtime library search path for MSVC"
        )

    def library_option(self, lib):
        return self.library_filename(lib)

    def find_library_file(self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename(name))
                if os.path.isfile(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/archive_util.py0000644000175100001730000002057414467657412023116 0ustar00runnerdocker"""distutils.archive_util

Utility functions for creating archive files (tarballs, zip files,
that sort of thing)."""

import os
from warnings import warn
import sys

try:
    import zipfile
except ImportError:
    zipfile = None


from .errors import DistutilsExecError
from .spawn import spawn
from .dir_util import mkpath
from ._log import log

try:
    from pwd import getpwnam
except ImportError:
    getpwnam = None

try:
    from grp import getgrnam
except ImportError:
    getgrnam = None


def _get_gid(name):
    """Returns a gid, given a group name."""
    if getgrnam is None or name is None:
        return None
    try:
        result = getgrnam(name)
    except KeyError:
        result = None
    if result is not None:
        return result[2]
    return None


def _get_uid(name):
    """Returns an uid, given a user name."""
    if getpwnam is None or name is None:
        return None
    try:
        result = getpwnam(name)
    except KeyError:
        result = None
    if result is not None:
        return result[2]
    return None


def make_tarball(
    base_name, base_dir, compress="gzip", verbose=0, dry_run=0, owner=None, group=None
):
    """Create a (possibly compressed) tar file from all the files under
    'base_dir'.

    'compress' must be "gzip" (the default), "bzip2", "xz", "compress", or
    None.  ("compress" will be deprecated in Python 3.2)

    'owner' and 'group' can be used to define an owner and a group for the
    archive that is being built. If not provided, the current owner and group
    will be used.

    The output tar file will be named 'base_dir' +  ".tar", possibly plus
    the appropriate compression extension (".gz", ".bz2", ".xz" or ".Z").

    Returns the output filename.
    """
    tar_compression = {
        'gzip': 'gz',
        'bzip2': 'bz2',
        'xz': 'xz',
        None: '',
        'compress': '',
    }
    compress_ext = {'gzip': '.gz', 'bzip2': '.bz2', 'xz': '.xz', 'compress': '.Z'}

    # flags for compression program, each element of list will be an argument
    if compress is not None and compress not in compress_ext.keys():
        raise ValueError(
            "bad value for 'compress': must be None, 'gzip', 'bzip2', "
            "'xz' or 'compress'"
        )

    archive_name = base_name + '.tar'
    if compress != 'compress':
        archive_name += compress_ext.get(compress, '')

    mkpath(os.path.dirname(archive_name), dry_run=dry_run)

    # creating the tarball
    import tarfile  # late import so Python build itself doesn't break

    log.info('Creating tar archive')

    uid = _get_uid(owner)
    gid = _get_gid(group)

    def _set_uid_gid(tarinfo):
        if gid is not None:
            tarinfo.gid = gid
            tarinfo.gname = group
        if uid is not None:
            tarinfo.uid = uid
            tarinfo.uname = owner
        return tarinfo

    if not dry_run:
        tar = tarfile.open(archive_name, 'w|%s' % tar_compression[compress])
        try:
            tar.add(base_dir, filter=_set_uid_gid)
        finally:
            tar.close()

    # compression using `compress`
    if compress == 'compress':
        warn("'compress' is deprecated.", DeprecationWarning)
        # the option varies depending on the platform
        compressed_name = archive_name + compress_ext[compress]
        if sys.platform == 'win32':
            cmd = [compress, archive_name, compressed_name]
        else:
            cmd = [compress, '-f', archive_name]
        spawn(cmd, dry_run=dry_run)
        return compressed_name

    return archive_name


def make_zipfile(base_name, base_dir, verbose=0, dry_run=0):  # noqa: C901
    """Create a zip file from all the files under 'base_dir'.

    The output zip file will be named 'base_name' + ".zip".  Uses either the
    "zipfile" Python module (if available) or the InfoZIP "zip" utility
    (if installed and found on the default search path).  If neither tool is
    available, raises DistutilsExecError.  Returns the name of the output zip
    file.
    """
    zip_filename = base_name + ".zip"
    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)

    # If zipfile module is not available, try spawning an external
    # 'zip' command.
    if zipfile is None:
        if verbose:
            zipoptions = "-r"
        else:
            zipoptions = "-rq"

        try:
            spawn(["zip", zipoptions, zip_filename, base_dir], dry_run=dry_run)
        except DistutilsExecError:
            # XXX really should distinguish between "couldn't find
            # external 'zip' command" and "zip failed".
            raise DistutilsExecError(
                (
                    "unable to create zip file '%s': "
                    "could neither import the 'zipfile' module nor "
                    "find a standalone zip utility"
                )
                % zip_filename
            )

    else:
        log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)

        if not dry_run:
            try:
                zip = zipfile.ZipFile(
                    zip_filename, "w", compression=zipfile.ZIP_DEFLATED
                )
            except RuntimeError:
                zip = zipfile.ZipFile(zip_filename, "w", compression=zipfile.ZIP_STORED)

            with zip:
                if base_dir != os.curdir:
                    path = os.path.normpath(os.path.join(base_dir, ''))
                    zip.write(path, path)
                    log.info("adding '%s'", path)
                for dirpath, dirnames, filenames in os.walk(base_dir):
                    for name in dirnames:
                        path = os.path.normpath(os.path.join(dirpath, name, ''))
                        zip.write(path, path)
                        log.info("adding '%s'", path)
                    for name in filenames:
                        path = os.path.normpath(os.path.join(dirpath, name))
                        if os.path.isfile(path):
                            zip.write(path, path)
                            log.info("adding '%s'", path)

    return zip_filename


ARCHIVE_FORMATS = {
    'gztar': (make_tarball, [('compress', 'gzip')], "gzip'ed tar-file"),
    'bztar': (make_tarball, [('compress', 'bzip2')], "bzip2'ed tar-file"),
    'xztar': (make_tarball, [('compress', 'xz')], "xz'ed tar-file"),
    'ztar': (make_tarball, [('compress', 'compress')], "compressed tar file"),
    'tar': (make_tarball, [('compress', None)], "uncompressed tar file"),
    'zip': (make_zipfile, [], "ZIP file"),
}


def check_archive_formats(formats):
    """Returns the first format from the 'format' list that is unknown.

    If all formats are known, returns None
    """
    for format in formats:
        if format not in ARCHIVE_FORMATS:
            return format
    return None


def make_archive(
    base_name,
    format,
    root_dir=None,
    base_dir=None,
    verbose=0,
    dry_run=0,
    owner=None,
    group=None,
):
    """Create an archive file (eg. zip or tar).

    'base_name' is the name of the file to create, minus any format-specific
    extension; 'format' is the archive format: one of "zip", "tar", "gztar",
    "bztar", "xztar", or "ztar".

    'root_dir' is a directory that will be the root directory of the
    archive; ie. we typically chdir into 'root_dir' before creating the
    archive.  'base_dir' is the directory where we start archiving from;
    ie. 'base_dir' will be the common prefix of all files and
    directories in the archive.  'root_dir' and 'base_dir' both default
    to the current directory.  Returns the name of the archive file.

    'owner' and 'group' are used when creating a tar archive. By default,
    uses the current owner and group.
    """
    save_cwd = os.getcwd()
    if root_dir is not None:
        log.debug("changing into '%s'", root_dir)
        base_name = os.path.abspath(base_name)
        if not dry_run:
            os.chdir(root_dir)

    if base_dir is None:
        base_dir = os.curdir

    kwargs = {'dry_run': dry_run}

    try:
        format_info = ARCHIVE_FORMATS[format]
    except KeyError:
        raise ValueError("unknown archive format '%s'" % format)

    func = format_info[0]
    for arg, val in format_info[1]:
        kwargs[arg] = val

    if format != 'zip':
        kwargs['owner'] = owner
        kwargs['group'] = group

    try:
        filename = func(base_name, base_dir, **kwargs)
    finally:
        if root_dir is not None:
            log.debug("changing back to '%s'", save_cwd)
            os.chdir(save_cwd)

    return filename
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/bcppcompiler.py0000644000175100001730000003460114467657412023113 0ustar00runnerdocker"""distutils.bcppcompiler

Contains BorlandCCompiler, an implementation of the abstract CCompiler class
for the Borland C++ compiler.
"""

# This implementation by Lyle Johnson, based on the original msvccompiler.py
# module and using the directions originally published by Gordon Williams.

# XXX looks like there's a LOT of overlap between these two classes:
# someone should sit down and factor out the common code as
# WindowsCCompiler!  --GPW


import os
import warnings

from .errors import (
    DistutilsExecError,
    CompileError,
    LibError,
    LinkError,
    UnknownFileError,
)
from .ccompiler import CCompiler, gen_preprocess_options
from .file_util import write_file
from .dep_util import newer
from ._log import log


warnings.warn(
    "bcppcompiler is deprecated and slated to be removed "
    "in the future. Please discontinue use or file an issue "
    "with pypa/distutils describing your use case.",
    DeprecationWarning,
)


class BCPPCompiler(CCompiler):
    """Concrete class that implements an interface to the Borland C/C++
    compiler, as defined by the CCompiler abstract class.
    """

    compiler_type = 'bcpp'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = _c_extensions + _cpp_extensions
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

    def __init__(self, verbose=0, dry_run=0, force=0):
        super().__init__(verbose, dry_run, force)

        # These executables are assumed to all be in the path.
        # Borland doesn't seem to use any special registry settings to
        # indicate their installation locations.

        self.cc = "bcc32.exe"
        self.linker = "ilink32.exe"
        self.lib = "tlib.exe"

        self.preprocess_options = None
        self.compile_options = ['/tWM', '/O2', '/q', '/g0']
        self.compile_options_debug = ['/tWM', '/Od', '/q', '/g0']

        self.ldflags_shared = ['/Tpd', '/Gn', '/q', '/x']
        self.ldflags_shared_debug = ['/Tpd', '/Gn', '/q', '/x']
        self.ldflags_static = []
        self.ldflags_exe = ['/Gn', '/q', '/x']
        self.ldflags_exe_debug = ['/Gn', '/q', '/x', '/r']

    # -- Worker methods ------------------------------------------------

    def compile(  # noqa: C901
        self,
        sources,
        output_dir=None,
        macros=None,
        include_dirs=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        depends=None,
    ):
        macros, objects, extra_postargs, pp_opts, build = self._setup_compile(
            output_dir, macros, include_dirs, sources, depends, extra_postargs
        )
        compile_opts = extra_preargs or []
        compile_opts.append('-c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            # XXX why do the normpath here?
            src = os.path.normpath(src)
            obj = os.path.normpath(obj)
            # XXX _setup_compile() did a mkpath() too but before the normpath.
            # Is it possible to skip the normpath?
            self.mkpath(os.path.dirname(obj))

            if ext == '.res':
                # This is already a binary file -- skip it.
                continue  # the 'for' loop
            if ext == '.rc':
                # This needs to be compiled to a .res file -- do it now.
                try:
                    self.spawn(["brcc32", "-fo", obj, src])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue  # the 'for' loop

            # The next two are both for the real compiler.
            if ext in self._c_extensions:
                input_opt = ""
            elif ext in self._cpp_extensions:
                input_opt = "-P"
            else:
                # Unknown file type -- no extra options.  The compiler
                # will probably fail, but let it just in case this is a
                # file the compiler recognizes even if we don't.
                input_opt = ""

            output_opt = "-o" + obj

            # Compiler command line syntax is: "bcc32 [options] file(s)".
            # Note that the source file names must appear at the end of
            # the command line.
            try:
                self.spawn(
                    [self.cc]
                    + compile_opts
                    + pp_opts
                    + [input_opt, output_opt]
                    + extra_postargs
                    + [src]
                )
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects

    # compile ()

    def create_static_lib(
        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
    ):
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname, output_dir=output_dir)

        if self._need_link(objects, output_filename):
            lib_args = [output_filename, '/u'] + objects
            if debug:
                pass  # XXX what goes here?
            try:
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    # create_static_lib ()

    def link(  # noqa: C901
        self,
        target_desc,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        # XXX this ignores 'build_temp'!  should follow the lead of
        # msvccompiler.py

        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        (libraries, library_dirs, runtime_library_dirs) = self._fix_lib_args(
            libraries, library_dirs, runtime_library_dirs
        )

        if runtime_library_dirs:
            log.warning(
                "I don't know what to do with 'runtime_library_dirs': %s",
                str(runtime_library_dirs),
            )

        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            # Figure out linker args based on type of target.
            if target_desc == CCompiler.EXECUTABLE:
                startup_obj = 'c0w32'
                if debug:
                    ld_args = self.ldflags_exe_debug[:]
                else:
                    ld_args = self.ldflags_exe[:]
            else:
                startup_obj = 'c0d32'
                if debug:
                    ld_args = self.ldflags_shared_debug[:]
                else:
                    ld_args = self.ldflags_shared[:]

            # Create a temporary exports file for use by the linker
            if export_symbols is None:
                def_file = ''
            else:
                head, tail = os.path.split(output_filename)
                modname, ext = os.path.splitext(tail)
                temp_dir = os.path.dirname(objects[0])  # preserve tree structure
                def_file = os.path.join(temp_dir, '%s.def' % modname)
                contents = ['EXPORTS']
                for sym in export_symbols or []:
                    contents.append('  {}=_{}'.format(sym, sym))
                self.execute(write_file, (def_file, contents), "writing %s" % def_file)

            # Borland C++ has problems with '/' in paths
            objects2 = map(os.path.normpath, objects)
            # split objects in .obj and .res files
            # Borland C++ needs them at different positions in the command line
            objects = [startup_obj]
            resources = []
            for file in objects2:
                (base, ext) = os.path.splitext(os.path.normcase(file))
                if ext == '.res':
                    resources.append(file)
                else:
                    objects.append(file)

            for ell in library_dirs:
                ld_args.append("/L%s" % os.path.normpath(ell))
            ld_args.append("/L.")  # we sometimes use relative paths

            # list of object files
            ld_args.extend(objects)

            # XXX the command-line syntax for Borland C++ is a bit wonky;
            # certain filenames are jammed together in one big string, but
            # comma-delimited.  This doesn't mesh too well with the
            # Unix-centric attitude (with a DOS/Windows quoting hack) of
            # 'spawn()', so constructing the argument list is a bit
            # awkward.  Note that doing the obvious thing and jamming all
            # the filenames and commas into one argument would be wrong,
            # because 'spawn()' would quote any filenames with spaces in
            # them.  Arghghh!.  Apparently it works fine as coded...

            # name of dll/exe file
            ld_args.extend([',', output_filename])
            # no map file and start libraries
            ld_args.append(',,')

            for lib in libraries:
                # see if we find it and if there is a bcpp specific lib
                # (xxx_bcpp.lib)
                libfile = self.find_library_file(library_dirs, lib, debug)
                if libfile is None:
                    ld_args.append(lib)
                    # probably a BCPP internal library -- don't warn
                else:
                    # full name which prefers bcpp_xxx.lib over xxx.lib
                    ld_args.append(libfile)

            # some default libraries
            ld_args.extend(('import32', 'cw32mt'))

            # def file for export symbols
            ld_args.extend([',', def_file])
            # add resource files
            ld_args.append(',')
            ld_args.extend(resources)

            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            self.mkpath(os.path.dirname(output_filename))
            try:
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)

        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    # link ()

    # -- Miscellaneous methods -----------------------------------------

    def find_library_file(self, dirs, lib, debug=0):
        # List of effective library names to try, in order of preference:
        # xxx_bcpp.lib is better than xxx.lib
        # and xxx_d.lib is better than xxx.lib if debug is set
        #
        # The "_bcpp" suffix is to handle a Python installation for people
        # with multiple compilers (primarily Distutils hackers, I suspect
        # ;-).  The idea is they'd have one static library for each
        # compiler they care about, since (almost?) every Windows compiler
        # seems to have a different format for static libraries.
        if debug:
            dlib = lib + "_d"
            try_names = (dlib + "_bcpp", lib + "_bcpp", dlib, lib)
        else:
            try_names = (lib + "_bcpp", lib)

        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename(name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

    # overwrite the one from CCompiler to support rc and res-files
    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
        if output_dir is None:
            output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            # use normcase to make sure '.rc' is really '.rc' and not '.RC'
            (base, ext) = os.path.splitext(os.path.normcase(src_name))
            if ext not in (self.src_extensions + ['.rc', '.res']):
                raise UnknownFileError(
                    "unknown file type '{}' (from '{}')".format(ext, src_name)
                )
            if strip_dir:
                base = os.path.basename(base)
            if ext == '.res':
                # these can go unchanged
                obj_names.append(os.path.join(output_dir, base + ext))
            elif ext == '.rc':
                # these need to be compiled to .res-files
                obj_names.append(os.path.join(output_dir, base + '.res'))
            else:
                obj_names.append(os.path.join(output_dir, base + self.obj_extension))
        return obj_names

    # object_filenames ()

    def preprocess(
        self,
        source,
        output_file=None,
        macros=None,
        include_dirs=None,
        extra_preargs=None,
        extra_postargs=None,
    ):
        (_, macros, include_dirs) = self._fix_compile_args(None, macros, include_dirs)
        pp_opts = gen_preprocess_options(macros, include_dirs)
        pp_args = ['cpp32.exe'] + pp_opts
        if output_file is not None:
            pp_args.append('-o' + output_file)
        if extra_preargs:
            pp_args[:0] = extra_preargs
        if extra_postargs:
            pp_args.extend(extra_postargs)
        pp_args.append(source)

        # We need to preprocess: either we're being forced to, or the
        # source file is newer than the target (or the target doesn't
        # exist).
        if self.force or output_file is None or newer(source, output_file):
            if output_file:
                self.mkpath(os.path.dirname(output_file))
            try:
                self.spawn(pp_args)
            except DistutilsExecError as msg:
                print(msg)
                raise CompileError(msg)

    # preprocess()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/ccompiler.py0000644000175100001730000013700314467657412022411 0ustar00runnerdocker"""distutils.ccompiler

Contains CCompiler, an abstract base class that defines the interface
for the Distutils compiler abstraction model."""

import sys
import os
import re
import warnings

from .errors import (
    CompileError,
    LinkError,
    UnknownFileError,
    DistutilsPlatformError,
    DistutilsModuleError,
)
from .spawn import spawn
from .file_util import move_file
from .dir_util import mkpath
from .dep_util import newer_group
from .util import split_quoted, execute
from ._log import log


class CCompiler:
    """Abstract base class to define the interface that must be implemented
    by real compiler classes.  Also has some utility methods used by
    several compiler classes.

    The basic idea behind a compiler abstraction class is that each
    instance can be used for all the compile/link steps in building a
    single project.  Thus, attributes common to all of those compile and
    link steps -- include directories, macros to define, libraries to link
    against, etc. -- are attributes of the compiler instance.  To allow for
    variability in how individual files are treated, most of those
    attributes may be varied on a per-compilation or per-link basis.
    """

    # 'compiler_type' is a class attribute that identifies this class.  It
    # keeps code that wants to know what kind of compiler it's dealing with
    # from having to import all possible compiler classes just to do an
    # 'isinstance'.  In concrete CCompiler subclasses, 'compiler_type'
    # should really, really be one of the keys of the 'compiler_class'
    # dictionary (see below -- used by the 'new_compiler()' factory
    # function) -- authors of new compiler interface classes are
    # responsible for updating 'compiler_class'!
    compiler_type = None

    # XXX things not handled by this compiler abstraction model:
    #   * client can't provide additional options for a compiler,
    #     e.g. warning, optimization, debugging flags.  Perhaps this
    #     should be the domain of concrete compiler abstraction classes
    #     (UnixCCompiler, MSVCCompiler, etc.) -- or perhaps the base
    #     class should have methods for the common ones.
    #   * can't completely override the include or library searchg
    #     path, ie. no "cc -I -Idir1 -Idir2" or "cc -L -Ldir1 -Ldir2".
    #     I'm not sure how widely supported this is even by Unix
    #     compilers, much less on other platforms.  And I'm even less
    #     sure how useful it is; maybe for cross-compiling, but
    #     support for that is a ways off.  (And anyways, cross
    #     compilers probably have a dedicated binary with the
    #     right paths compiled in.  I hope.)
    #   * can't do really freaky things with the library list/library
    #     dirs, e.g. "-Ldir1 -lfoo -Ldir2 -lfoo" to link against
    #     different versions of libfoo.a in different locations.  I
    #     think this is useless without the ability to null out the
    #     library search path anyways.

    # Subclasses that rely on the standard filename generation methods
    # implemented below should override these; see the comment near
    # those methods ('object_filenames()' et. al.) for details:
    src_extensions = None  # list of strings
    obj_extension = None  # string
    static_lib_extension = None
    shared_lib_extension = None  # string
    static_lib_format = None  # format string
    shared_lib_format = None  # prob. same as static_lib_format
    exe_extension = None  # string

    # Default language settings. language_map is used to detect a source
    # file or Extension target language, checking source filenames.
    # language_order is used to detect the language precedence, when deciding
    # what language to use when mixing source types. For example, if some
    # extension has two files with ".c" extension, and one with ".cpp", it
    # is still linked as c++.
    language_map = {
        ".c": "c",
        ".cc": "c++",
        ".cpp": "c++",
        ".cxx": "c++",
        ".m": "objc",
    }
    language_order = ["c++", "objc", "c"]

    include_dirs = []
    """
    include dirs specific to this compiler class
    """

    library_dirs = []
    """
    library dirs specific to this compiler class
    """

    def __init__(self, verbose=0, dry_run=0, force=0):
        self.dry_run = dry_run
        self.force = force
        self.verbose = verbose

        # 'output_dir': a common output directory for object, library,
        # shared object, and shared library files
        self.output_dir = None

        # 'macros': a list of macro definitions (or undefinitions).  A
        # macro definition is a 2-tuple (name, value), where the value is
        # either a string or None (no explicit value).  A macro
        # undefinition is a 1-tuple (name,).
        self.macros = []

        # 'include_dirs': a list of directories to search for include files
        self.include_dirs = []

        # 'libraries': a list of libraries to include in any link
        # (library names, not filenames: eg. "foo" not "libfoo.a")
        self.libraries = []

        # 'library_dirs': a list of directories to search for libraries
        self.library_dirs = []

        # 'runtime_library_dirs': a list of directories to search for
        # shared libraries/objects at runtime
        self.runtime_library_dirs = []

        # 'objects': a list of object files (or similar, such as explicitly
        # named library files) to include on any link
        self.objects = []

        for key in self.executables.keys():
            self.set_executable(key, self.executables[key])

    def set_executables(self, **kwargs):
        """Define the executables (and options for them) that will be run
        to perform the various stages of compilation.  The exact set of
        executables that may be specified here depends on the compiler
        class (via the 'executables' class attribute), but most will have:
          compiler      the C/C++ compiler
          linker_so     linker used to create shared objects and libraries
          linker_exe    linker used to create binary executables
          archiver      static library creator

        On platforms with a command-line (Unix, DOS/Windows), each of these
        is a string that will be split into executable name and (optional)
        list of arguments.  (Splitting the string is done similarly to how
        Unix shells operate: words are delimited by spaces, but quotes and
        backslashes can override this.  See
        'distutils.util.split_quoted()'.)
        """

        # Note that some CCompiler implementation classes will define class
        # attributes 'cpp', 'cc', etc. with hard-coded executable names;
        # this is appropriate when a compiler class is for exactly one
        # compiler/OS combination (eg. MSVCCompiler).  Other compiler
        # classes (UnixCCompiler, in particular) are driven by information
        # discovered at run-time, since there are many different ways to do
        # basically the same things with Unix C compilers.

        for key in kwargs:
            if key not in self.executables:
                raise ValueError(
                    "unknown executable '%s' for class %s"
                    % (key, self.__class__.__name__)
                )
            self.set_executable(key, kwargs[key])

    def set_executable(self, key, value):
        if isinstance(value, str):
            setattr(self, key, split_quoted(value))
        else:
            setattr(self, key, value)

    def _find_macro(self, name):
        i = 0
        for defn in self.macros:
            if defn[0] == name:
                return i
            i += 1
        return None

    def _check_macro_definitions(self, definitions):
        """Ensures that every element of 'definitions' is a valid macro
        definition, ie. either (name,value) 2-tuple or a (name,) tuple.  Do
        nothing if all definitions are OK, raise TypeError otherwise.
        """
        for defn in definitions:
            if not (
                isinstance(defn, tuple)
                and (
                    len(defn) in (1, 2)
                    and (isinstance(defn[1], str) or defn[1] is None)
                )
                and isinstance(defn[0], str)
            ):
                raise TypeError(
                    ("invalid macro definition '%s': " % defn)
                    + "must be tuple (string,), (string, string), or "
                    + "(string, None)"
                )

    # -- Bookkeeping methods -------------------------------------------

    def define_macro(self, name, value=None):
        """Define a preprocessor macro for all compilations driven by this
        compiler object.  The optional parameter 'value' should be a
        string; if it is not supplied, then the macro will be defined
        without an explicit value and the exact outcome depends on the
        compiler used (XXX true? does ANSI say anything about this?)
        """
        # Delete from the list of macro definitions/undefinitions if
        # already there (so that this one will take precedence).
        i = self._find_macro(name)
        if i is not None:
            del self.macros[i]

        self.macros.append((name, value))

    def undefine_macro(self, name):
        """Undefine a preprocessor macro for all compilations driven by
        this compiler object.  If the same macro is defined by
        'define_macro()' and undefined by 'undefine_macro()' the last call
        takes precedence (including multiple redefinitions or
        undefinitions).  If the macro is redefined/undefined on a
        per-compilation basis (ie. in the call to 'compile()'), then that
        takes precedence.
        """
        # Delete from the list of macro definitions/undefinitions if
        # already there (so that this one will take precedence).
        i = self._find_macro(name)
        if i is not None:
            del self.macros[i]

        undefn = (name,)
        self.macros.append(undefn)

    def add_include_dir(self, dir):
        """Add 'dir' to the list of directories that will be searched for
        header files.  The compiler is instructed to search directories in
        the order in which they are supplied by successive calls to
        'add_include_dir()'.
        """
        self.include_dirs.append(dir)

    def set_include_dirs(self, dirs):
        """Set the list of directories that will be searched to 'dirs' (a
        list of strings).  Overrides any preceding calls to
        'add_include_dir()'; subsequence calls to 'add_include_dir()' add
        to the list passed to 'set_include_dirs()'.  This does not affect
        any list of standard include directories that the compiler may
        search by default.
        """
        self.include_dirs = dirs[:]

    def add_library(self, libname):
        """Add 'libname' to the list of libraries that will be included in
        all links driven by this compiler object.  Note that 'libname'
        should *not* be the name of a file containing a library, but the
        name of the library itself: the actual filename will be inferred by
        the linker, the compiler, or the compiler class (depending on the
        platform).

        The linker will be instructed to link against libraries in the
        order they were supplied to 'add_library()' and/or
        'set_libraries()'.  It is perfectly valid to duplicate library
        names; the linker will be instructed to link against libraries as
        many times as they are mentioned.
        """
        self.libraries.append(libname)

    def set_libraries(self, libnames):
        """Set the list of libraries to be included in all links driven by
        this compiler object to 'libnames' (a list of strings).  This does
        not affect any standard system libraries that the linker may
        include by default.
        """
        self.libraries = libnames[:]

    def add_library_dir(self, dir):
        """Add 'dir' to the list of directories that will be searched for
        libraries specified to 'add_library()' and 'set_libraries()'.  The
        linker will be instructed to search for libraries in the order they
        are supplied to 'add_library_dir()' and/or 'set_library_dirs()'.
        """
        self.library_dirs.append(dir)

    def set_library_dirs(self, dirs):
        """Set the list of library search directories to 'dirs' (a list of
        strings).  This does not affect any standard library search path
        that the linker may search by default.
        """
        self.library_dirs = dirs[:]

    def add_runtime_library_dir(self, dir):
        """Add 'dir' to the list of directories that will be searched for
        shared libraries at runtime.
        """
        self.runtime_library_dirs.append(dir)

    def set_runtime_library_dirs(self, dirs):
        """Set the list of directories to search for shared libraries at
        runtime to 'dirs' (a list of strings).  This does not affect any
        standard search path that the runtime linker may search by
        default.
        """
        self.runtime_library_dirs = dirs[:]

    def add_link_object(self, object):
        """Add 'object' to the list of object files (or analogues, such as
        explicitly named library files or the output of "resource
        compilers") to be included in every link driven by this compiler
        object.
        """
        self.objects.append(object)

    def set_link_objects(self, objects):
        """Set the list of object files (or analogues) to be included in
        every link to 'objects'.  This does not affect any standard object
        files that the linker may include by default (such as system
        libraries).
        """
        self.objects = objects[:]

    # -- Private utility methods --------------------------------------
    # (here for the convenience of subclasses)

    # Helper method to prep compiler in subclass compile() methods

    def _setup_compile(self, outdir, macros, incdirs, sources, depends, extra):
        """Process arguments and decide which source files to compile."""
        outdir, macros, incdirs = self._fix_compile_args(outdir, macros, incdirs)

        if extra is None:
            extra = []

        # Get the list of expected output (object) files
        objects = self.object_filenames(sources, strip_dir=0, output_dir=outdir)
        assert len(objects) == len(sources)

        pp_opts = gen_preprocess_options(macros, incdirs)

        build = {}
        for i in range(len(sources)):
            src = sources[i]
            obj = objects[i]
            ext = os.path.splitext(src)[1]
            self.mkpath(os.path.dirname(obj))
            build[obj] = (src, ext)

        return macros, objects, extra, pp_opts, build

    def _get_cc_args(self, pp_opts, debug, before):
        # works for unixccompiler, cygwinccompiler
        cc_args = pp_opts + ['-c']
        if debug:
            cc_args[:0] = ['-g']
        if before:
            cc_args[:0] = before
        return cc_args

    def _fix_compile_args(self, output_dir, macros, include_dirs):
        """Typecheck and fix-up some of the arguments to the 'compile()'
        method, and return fixed-up values.  Specifically: if 'output_dir'
        is None, replaces it with 'self.output_dir'; ensures that 'macros'
        is a list, and augments it with 'self.macros'; ensures that
        'include_dirs' is a list, and augments it with 'self.include_dirs'.
        Guarantees that the returned values are of the correct type,
        i.e. for 'output_dir' either string or None, and for 'macros' and
        'include_dirs' either list or None.
        """
        if output_dir is None:
            output_dir = self.output_dir
        elif not isinstance(output_dir, str):
            raise TypeError("'output_dir' must be a string or None")

        if macros is None:
            macros = self.macros
        elif isinstance(macros, list):
            macros = macros + (self.macros or [])
        else:
            raise TypeError("'macros' (if supplied) must be a list of tuples")

        if include_dirs is None:
            include_dirs = list(self.include_dirs)
        elif isinstance(include_dirs, (list, tuple)):
            include_dirs = list(include_dirs) + (self.include_dirs or [])
        else:
            raise TypeError("'include_dirs' (if supplied) must be a list of strings")

        # add include dirs for class
        include_dirs += self.__class__.include_dirs

        return output_dir, macros, include_dirs

    def _prep_compile(self, sources, output_dir, depends=None):
        """Decide which source files must be recompiled.

        Determine the list of object files corresponding to 'sources',
        and figure out which ones really need to be recompiled.
        Return a list of all object files and a dictionary telling
        which source files can be skipped.
        """
        # Get the list of expected output (object) files
        objects = self.object_filenames(sources, output_dir=output_dir)
        assert len(objects) == len(sources)

        # Return an empty dict for the "which source files can be skipped"
        # return value to preserve API compatibility.
        return objects, {}

    def _fix_object_args(self, objects, output_dir):
        """Typecheck and fix up some arguments supplied to various methods.
        Specifically: ensure that 'objects' is a list; if output_dir is
        None, replace with self.output_dir.  Return fixed versions of
        'objects' and 'output_dir'.
        """
        if not isinstance(objects, (list, tuple)):
            raise TypeError("'objects' must be a list or tuple of strings")
        objects = list(objects)

        if output_dir is None:
            output_dir = self.output_dir
        elif not isinstance(output_dir, str):
            raise TypeError("'output_dir' must be a string or None")

        return (objects, output_dir)

    def _fix_lib_args(self, libraries, library_dirs, runtime_library_dirs):
        """Typecheck and fix up some of the arguments supplied to the
        'link_*' methods.  Specifically: ensure that all arguments are
        lists, and augment them with their permanent versions
        (eg. 'self.libraries' augments 'libraries').  Return a tuple with
        fixed versions of all arguments.
        """
        if libraries is None:
            libraries = self.libraries
        elif isinstance(libraries, (list, tuple)):
            libraries = list(libraries) + (self.libraries or [])
        else:
            raise TypeError("'libraries' (if supplied) must be a list of strings")

        if library_dirs is None:
            library_dirs = self.library_dirs
        elif isinstance(library_dirs, (list, tuple)):
            library_dirs = list(library_dirs) + (self.library_dirs or [])
        else:
            raise TypeError("'library_dirs' (if supplied) must be a list of strings")

        # add library dirs for class
        library_dirs += self.__class__.library_dirs

        if runtime_library_dirs is None:
            runtime_library_dirs = self.runtime_library_dirs
        elif isinstance(runtime_library_dirs, (list, tuple)):
            runtime_library_dirs = list(runtime_library_dirs) + (
                self.runtime_library_dirs or []
            )
        else:
            raise TypeError(
                "'runtime_library_dirs' (if supplied) " "must be a list of strings"
            )

        return (libraries, library_dirs, runtime_library_dirs)

    def _need_link(self, objects, output_file):
        """Return true if we need to relink the files listed in 'objects'
        to recreate 'output_file'.
        """
        if self.force:
            return True
        else:
            if self.dry_run:
                newer = newer_group(objects, output_file, missing='newer')
            else:
                newer = newer_group(objects, output_file)
            return newer

    def detect_language(self, sources):
        """Detect the language of a given file, or list of files. Uses
        language_map, and language_order to do the job.
        """
        if not isinstance(sources, list):
            sources = [sources]
        lang = None
        index = len(self.language_order)
        for source in sources:
            base, ext = os.path.splitext(source)
            extlang = self.language_map.get(ext)
            try:
                extindex = self.language_order.index(extlang)
                if extindex < index:
                    lang = extlang
                    index = extindex
            except ValueError:
                pass
        return lang

    # -- Worker methods ------------------------------------------------
    # (must be implemented by subclasses)

    def preprocess(
        self,
        source,
        output_file=None,
        macros=None,
        include_dirs=None,
        extra_preargs=None,
        extra_postargs=None,
    ):
        """Preprocess a single C/C++ source file, named in 'source'.
        Output will be written to file named 'output_file', or stdout if
        'output_file' not supplied.  'macros' is a list of macro
        definitions as for 'compile()', which will augment the macros set
        with 'define_macro()' and 'undefine_macro()'.  'include_dirs' is a
        list of directory names that will be added to the default list.

        Raises PreprocessError on failure.
        """
        pass

    def compile(
        self,
        sources,
        output_dir=None,
        macros=None,
        include_dirs=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        depends=None,
    ):
        """Compile one or more source files.

        'sources' must be a list of filenames, most likely C/C++
        files, but in reality anything that can be handled by a
        particular compiler and compiler class (eg. MSVCCompiler can
        handle resource files in 'sources').  Return a list of object
        filenames, one per source filename in 'sources'.  Depending on
        the implementation, not all source files will necessarily be
        compiled, but all corresponding object filenames will be
        returned.

        If 'output_dir' is given, object files will be put under it, while
        retaining their original path component.  That is, "foo/bar.c"
        normally compiles to "foo/bar.o" (for a Unix implementation); if
        'output_dir' is "build", then it would compile to
        "build/foo/bar.o".

        'macros', if given, must be a list of macro definitions.  A macro
        definition is either a (name, value) 2-tuple or a (name,) 1-tuple.
        The former defines a macro; if the value is None, the macro is
        defined without an explicit value.  The 1-tuple case undefines a
        macro.  Later definitions/redefinitions/ undefinitions take
        precedence.

        'include_dirs', if given, must be a list of strings, the
        directories to add to the default include file search path for this
        compilation only.

        'debug' is a boolean; if true, the compiler will be instructed to
        output debug symbols in (or alongside) the object file(s).

        'extra_preargs' and 'extra_postargs' are implementation- dependent.
        On platforms that have the notion of a command-line (e.g. Unix,
        DOS/Windows), they are most likely lists of strings: extra
        command-line arguments to prepend/append to the compiler command
        line.  On other platforms, consult the implementation class
        documentation.  In any event, they are intended as an escape hatch
        for those occasions when the abstract compiler framework doesn't
        cut the mustard.

        'depends', if given, is a list of filenames that all targets
        depend on.  If a source file is older than any file in
        depends, then the source file will be recompiled.  This
        supports dependency tracking, but only at a coarse
        granularity.

        Raises CompileError on failure.
        """
        # A concrete compiler class can either override this method
        # entirely or implement _compile().
        macros, objects, extra_postargs, pp_opts, build = self._setup_compile(
            output_dir, macros, include_dirs, sources, depends, extra_postargs
        )
        cc_args = self._get_cc_args(pp_opts, debug, extra_preargs)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            self._compile(obj, src, ext, cc_args, extra_postargs, pp_opts)

        # Return *all* object filenames, not just the ones we just built.
        return objects

    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        """Compile 'src' to product 'obj'."""
        # A concrete compiler class that does not override compile()
        # should implement _compile().
        pass

    def create_static_lib(
        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
    ):
        """Link a bunch of stuff together to create a static library file.
        The "bunch of stuff" consists of the list of object files supplied
        as 'objects', the extra object files supplied to
        'add_link_object()' and/or 'set_link_objects()', the libraries
        supplied to 'add_library()' and/or 'set_libraries()', and the
        libraries supplied as 'libraries' (if any).

        'output_libname' should be a library name, not a filename; the
        filename will be inferred from the library name.  'output_dir' is
        the directory where the library file will be put.

        'debug' is a boolean; if true, debugging information will be
        included in the library (note that on most platforms, it is the
        compile step where this matters: the 'debug' flag is included here
        just for consistency).

        'target_lang' is the target language for which the given objects
        are being compiled. This allows specific linkage time treatment of
        certain languages.

        Raises LibError on failure.
        """
        pass

    # values for target_desc parameter in link()
    SHARED_OBJECT = "shared_object"
    SHARED_LIBRARY = "shared_library"
    EXECUTABLE = "executable"

    def link(
        self,
        target_desc,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        """Link a bunch of stuff together to create an executable or
        shared library file.

        The "bunch of stuff" consists of the list of object files supplied
        as 'objects'.  'output_filename' should be a filename.  If
        'output_dir' is supplied, 'output_filename' is relative to it
        (i.e. 'output_filename' can provide directory components if
        needed).

        'libraries' is a list of libraries to link against.  These are
        library names, not filenames, since they're translated into
        filenames in a platform-specific way (eg. "foo" becomes "libfoo.a"
        on Unix and "foo.lib" on DOS/Windows).  However, they can include a
        directory component, which means the linker will look in that
        specific directory rather than searching all the normal locations.

        'library_dirs', if supplied, should be a list of directories to
        search for libraries that were specified as bare library names
        (ie. no directory component).  These are on top of the system
        default and those supplied to 'add_library_dir()' and/or
        'set_library_dirs()'.  'runtime_library_dirs' is a list of
        directories that will be embedded into the shared library and used
        to search for other shared libraries that *it* depends on at
        run-time.  (This may only be relevant on Unix.)

        'export_symbols' is a list of symbols that the shared library will
        export.  (This appears to be relevant only on Windows.)

        'debug' is as for 'compile()' and 'create_static_lib()', with the
        slight distinction that it actually matters on most platforms (as
        opposed to 'create_static_lib()', which includes a 'debug' flag
        mostly for form's sake).

        'extra_preargs' and 'extra_postargs' are as for 'compile()' (except
        of course that they supply command-line arguments for the
        particular linker being used).

        'target_lang' is the target language for which the given objects
        are being compiled. This allows specific linkage time treatment of
        certain languages.

        Raises LinkError on failure.
        """
        raise NotImplementedError

    # Old 'link_*()' methods, rewritten to use the new 'link()' method.

    def link_shared_lib(
        self,
        objects,
        output_libname,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        self.link(
            CCompiler.SHARED_LIBRARY,
            objects,
            self.library_filename(output_libname, lib_type='shared'),
            output_dir,
            libraries,
            library_dirs,
            runtime_library_dirs,
            export_symbols,
            debug,
            extra_preargs,
            extra_postargs,
            build_temp,
            target_lang,
        )

    def link_shared_object(
        self,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        self.link(
            CCompiler.SHARED_OBJECT,
            objects,
            output_filename,
            output_dir,
            libraries,
            library_dirs,
            runtime_library_dirs,
            export_symbols,
            debug,
            extra_preargs,
            extra_postargs,
            build_temp,
            target_lang,
        )

    def link_executable(
        self,
        objects,
        output_progname,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        target_lang=None,
    ):
        self.link(
            CCompiler.EXECUTABLE,
            objects,
            self.executable_filename(output_progname),
            output_dir,
            libraries,
            library_dirs,
            runtime_library_dirs,
            None,
            debug,
            extra_preargs,
            extra_postargs,
            None,
            target_lang,
        )

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function; there is
    # no appropriate default implementation so subclasses should
    # implement all of these.

    def library_dir_option(self, dir):
        """Return the compiler option to add 'dir' to the list of
        directories searched for libraries.
        """
        raise NotImplementedError

    def runtime_library_dir_option(self, dir):
        """Return the compiler option to add 'dir' to the list of
        directories searched for runtime libraries.
        """
        raise NotImplementedError

    def library_option(self, lib):
        """Return the compiler option to add 'lib' to the list of libraries
        linked into the shared library or executable.
        """
        raise NotImplementedError

    def has_function(  # noqa: C901
        self,
        funcname,
        includes=None,
        include_dirs=None,
        libraries=None,
        library_dirs=None,
    ):
        """Return a boolean indicating whether funcname is provided as
        a symbol on the current platform.  The optional arguments can
        be used to augment the compilation environment.

        The libraries argument is a list of flags to be passed to the
        linker to make additional symbol definitions available for
        linking.

        The includes and include_dirs arguments are deprecated.
        Usually, supplying include files with function declarations
        will cause function detection to fail even in cases where the
        symbol is available for linking.

        """
        # this can't be included at module scope because it tries to
        # import math which might not be available at that point - maybe
        # the necessary logic should just be inlined?
        import tempfile

        if includes is None:
            includes = []
        else:
            warnings.warn("includes is deprecated", DeprecationWarning)
        if include_dirs is None:
            include_dirs = []
        else:
            warnings.warn("include_dirs is deprecated", DeprecationWarning)
        if libraries is None:
            libraries = []
        if library_dirs is None:
            library_dirs = []
        fd, fname = tempfile.mkstemp(".c", funcname, text=True)
        f = os.fdopen(fd, "w")
        try:
            for incl in includes:
                f.write("""#include "%s"\n""" % incl)
            if not includes:
                # Use "char func(void);" as the prototype to follow
                # what autoconf does.  This prototype does not match
                # any well-known function the compiler might recognize
                # as a builtin, so this ends up as a true link test.
                # Without a fake prototype, the test would need to
                # know the exact argument types, and the has_function
                # interface does not provide that level of information.
                f.write(
                    """\
#ifdef __cplusplus
extern "C"
#endif
char %s(void);
"""
                    % funcname
                )
            f.write(
                """\
int main (int argc, char **argv) {
    %s();
    return 0;
}
"""
                % funcname
            )
        finally:
            f.close()
        try:
            objects = self.compile([fname], include_dirs=include_dirs)
        except CompileError:
            return False
        finally:
            os.remove(fname)

        try:
            self.link_executable(
                objects, "a.out", libraries=libraries, library_dirs=library_dirs
            )
        except (LinkError, TypeError):
            return False
        else:
            os.remove(
                self.executable_filename("a.out", output_dir=self.output_dir or '')
            )
        finally:
            for fn in objects:
                os.remove(fn)
        return True

    def find_library_file(self, dirs, lib, debug=0):
        """Search the specified list of directories for a static or shared
        library file 'lib' and return the full path to that file.  If
        'debug' true, look for a debugging version (if that makes sense on
        the current platform).  Return None if 'lib' wasn't found in any of
        the specified directories.
        """
        raise NotImplementedError

    # -- Filename generation methods -----------------------------------

    # The default implementation of the filename generating methods are
    # prejudiced towards the Unix/DOS/Windows view of the world:
    #   * object files are named by replacing the source file extension
    #     (eg. .c/.cpp -> .o/.obj)
    #   * library files (shared or static) are named by plugging the
    #     library name and extension into a format string, eg.
    #     "lib%s.%s" % (lib_name, ".a") for Unix static libraries
    #   * executables are named by appending an extension (possibly
    #     empty) to the program name: eg. progname + ".exe" for
    #     Windows
    #
    # To reduce redundant code, these methods expect to find
    # several attributes in the current object (presumably defined
    # as class attributes):
    #   * src_extensions -
    #     list of C/C++ source file extensions, eg. ['.c', '.cpp']
    #   * obj_extension -
    #     object file extension, eg. '.o' or '.obj'
    #   * static_lib_extension -
    #     extension for static library files, eg. '.a' or '.lib'
    #   * shared_lib_extension -
    #     extension for shared library/object files, eg. '.so', '.dll'
    #   * static_lib_format -
    #     format string for generating static library filenames,
    #     eg. 'lib%s.%s' or '%s.%s'
    #   * shared_lib_format
    #     format string for generating shared library filenames
    #     (probably same as static_lib_format, since the extension
    #     is one of the intended parameters to the format string)
    #   * exe_extension -
    #     extension for executable files, eg. '' or '.exe'

    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
        if output_dir is None:
            output_dir = ''
        return list(
            self._make_out_path(output_dir, strip_dir, src_name)
            for src_name in source_filenames
        )

    @property
    def out_extensions(self):
        return dict.fromkeys(self.src_extensions, self.obj_extension)

    def _make_out_path(self, output_dir, strip_dir, src_name):
        base, ext = os.path.splitext(src_name)
        base = self._make_relative(base)
        try:
            new_ext = self.out_extensions[ext]
        except LookupError:
            raise UnknownFileError(
                "unknown file type '{}' (from '{}')".format(ext, src_name)
            )
        if strip_dir:
            base = os.path.basename(base)
        return os.path.join(output_dir, base + new_ext)

    @staticmethod
    def _make_relative(base):
        """
        In order to ensure that a filename always honors the
        indicated output_dir, make sure it's relative.
        Ref python/cpython#37775.
        """
        # Chop off the drive
        no_drive = os.path.splitdrive(base)[1]
        # If abs, chop off leading /
        return no_drive[os.path.isabs(no_drive) :]

    def shared_object_filename(self, basename, strip_dir=0, output_dir=''):
        assert output_dir is not None
        if strip_dir:
            basename = os.path.basename(basename)
        return os.path.join(output_dir, basename + self.shared_lib_extension)

    def executable_filename(self, basename, strip_dir=0, output_dir=''):
        assert output_dir is not None
        if strip_dir:
            basename = os.path.basename(basename)
        return os.path.join(output_dir, basename + (self.exe_extension or ''))

    def library_filename(
        self, libname, lib_type='static', strip_dir=0, output_dir=''  # or 'shared'
    ):
        assert output_dir is not None
        expected = '"static", "shared", "dylib", "xcode_stub"'
        if lib_type not in eval(expected):
            raise ValueError(f"'lib_type' must be {expected}")
        fmt = getattr(self, lib_type + "_lib_format")
        ext = getattr(self, lib_type + "_lib_extension")

        dir, base = os.path.split(libname)
        filename = fmt % (base, ext)
        if strip_dir:
            dir = ''

        return os.path.join(output_dir, dir, filename)

    # -- Utility methods -----------------------------------------------

    def announce(self, msg, level=1):
        log.debug(msg)

    def debug_print(self, msg):
        from distutils.debug import DEBUG

        if DEBUG:
            print(msg)

    def warn(self, msg):
        sys.stderr.write("warning: %s\n" % msg)

    def execute(self, func, args, msg=None, level=1):
        execute(func, args, msg, self.dry_run)

    def spawn(self, cmd, **kwargs):
        spawn(cmd, dry_run=self.dry_run, **kwargs)

    def move_file(self, src, dst):
        return move_file(src, dst, dry_run=self.dry_run)

    def mkpath(self, name, mode=0o777):
        mkpath(name, mode, dry_run=self.dry_run)


# Map a sys.platform/os.name ('posix', 'nt') to the default compiler
# type for that platform. Keys are interpreted as re match
# patterns. Order is important; platform mappings are preferred over
# OS names.
_default_compilers = (
    # Platform string mappings
    # on a cygwin built python we can use gcc like an ordinary UNIXish
    # compiler
    ('cygwin.*', 'unix'),
    # OS name mappings
    ('posix', 'unix'),
    ('nt', 'msvc'),
)


def get_default_compiler(osname=None, platform=None):
    """Determine the default compiler to use for the given platform.

    osname should be one of the standard Python OS names (i.e. the
    ones returned by os.name) and platform the common value
    returned by sys.platform for the platform in question.

    The default values are os.name and sys.platform in case the
    parameters are not given.
    """
    if osname is None:
        osname = os.name
    if platform is None:
        platform = sys.platform
    for pattern, compiler in _default_compilers:
        if (
            re.match(pattern, platform) is not None
            or re.match(pattern, osname) is not None
        ):
            return compiler
    # Default to Unix compiler
    return 'unix'


# Map compiler types to (module_name, class_name) pairs -- ie. where to
# find the code that implements an interface to this compiler.  (The module
# is assumed to be in the 'distutils' package.)
compiler_class = {
    'unix': ('unixccompiler', 'UnixCCompiler', "standard UNIX-style compiler"),
    'msvc': ('_msvccompiler', 'MSVCCompiler', "Microsoft Visual C++"),
    'cygwin': (
        'cygwinccompiler',
        'CygwinCCompiler',
        "Cygwin port of GNU C Compiler for Win32",
    ),
    'mingw32': (
        'cygwinccompiler',
        'Mingw32CCompiler',
        "Mingw32 port of GNU C Compiler for Win32",
    ),
    'bcpp': ('bcppcompiler', 'BCPPCompiler', "Borland C++ Compiler"),
}


def show_compilers():
    """Print list of available compilers (used by the "--help-compiler"
    options to "build", "build_ext", "build_clib").
    """
    # XXX this "knows" that the compiler option it's describing is
    # "--compiler", which just happens to be the case for the three
    # commands that use it.
    from distutils.fancy_getopt import FancyGetopt

    compilers = []
    for compiler in compiler_class.keys():
        compilers.append(("compiler=" + compiler, None, compiler_class[compiler][2]))
    compilers.sort()
    pretty_printer = FancyGetopt(compilers)
    pretty_printer.print_help("List of available compilers:")


def new_compiler(plat=None, compiler=None, verbose=0, dry_run=0, force=0):
    """Generate an instance of some CCompiler subclass for the supplied
    platform/compiler combination.  'plat' defaults to 'os.name'
    (eg. 'posix', 'nt'), and 'compiler' defaults to the default compiler
    for that platform.  Currently only 'posix' and 'nt' are supported, and
    the default compilers are "traditional Unix interface" (UnixCCompiler
    class) and Visual C++ (MSVCCompiler class).  Note that it's perfectly
    possible to ask for a Unix compiler object under Windows, and a
    Microsoft compiler object under Unix -- if you supply a value for
    'compiler', 'plat' is ignored.
    """
    if plat is None:
        plat = os.name

    try:
        if compiler is None:
            compiler = get_default_compiler(plat)

        (module_name, class_name, long_description) = compiler_class[compiler]
    except KeyError:
        msg = "don't know how to compile C/C++ code on platform '%s'" % plat
        if compiler is not None:
            msg = msg + " with '%s' compiler" % compiler
        raise DistutilsPlatformError(msg)

    try:
        module_name = "distutils." + module_name
        __import__(module_name)
        module = sys.modules[module_name]
        klass = vars(module)[class_name]
    except ImportError:
        raise DistutilsModuleError(
            "can't compile C/C++ code: unable to load module '%s'" % module_name
        )
    except KeyError:
        raise DistutilsModuleError(
            "can't compile C/C++ code: unable to find class '%s' "
            "in module '%s'" % (class_name, module_name)
        )

    # XXX The None is necessary to preserve backwards compatibility
    # with classes that expect verbose to be the first positional
    # argument.
    return klass(None, dry_run, force)


def gen_preprocess_options(macros, include_dirs):
    """Generate C pre-processor options (-D, -U, -I) as used by at least
    two types of compilers: the typical Unix compiler and Visual C++.
    'macros' is the usual thing, a list of 1- or 2-tuples, where (name,)
    means undefine (-U) macro 'name', and (name,value) means define (-D)
    macro 'name' to 'value'.  'include_dirs' is just a list of directory
    names to be added to the header file search path (-I).  Returns a list
    of command-line options suitable for either Unix compilers or Visual
    C++.
    """
    # XXX it would be nice (mainly aesthetic, and so we don't generate
    # stupid-looking command lines) to go over 'macros' and eliminate
    # redundant definitions/undefinitions (ie. ensure that only the
    # latest mention of a particular macro winds up on the command
    # line).  I don't think it's essential, though, since most (all?)
    # Unix C compilers only pay attention to the latest -D or -U
    # mention of a macro on their command line.  Similar situation for
    # 'include_dirs'.  I'm punting on both for now.  Anyways, weeding out
    # redundancies like this should probably be the province of
    # CCompiler, since the data structures used are inherited from it
    # and therefore common to all CCompiler classes.
    pp_opts = []
    for macro in macros:
        if not (isinstance(macro, tuple) and 1 <= len(macro) <= 2):
            raise TypeError(
                "bad macro definition '%s': "
                "each element of 'macros' list must be a 1- or 2-tuple" % macro
            )

        if len(macro) == 1:  # undefine this macro
            pp_opts.append("-U%s" % macro[0])
        elif len(macro) == 2:
            if macro[1] is None:  # define with no explicit value
                pp_opts.append("-D%s" % macro[0])
            else:
                # XXX *don't* need to be clever about quoting the
                # macro value here, because we're going to avoid the
                # shell at all costs when we spawn the command!
                pp_opts.append("-D%s=%s" % macro)

    for dir in include_dirs:
        pp_opts.append("-I%s" % dir)
    return pp_opts


def gen_lib_options(compiler, library_dirs, runtime_library_dirs, libraries):
    """Generate linker options for searching library directories and
    linking with specific libraries.  'libraries' and 'library_dirs' are,
    respectively, lists of library names (not filenames!) and search
    directories.  Returns a list of command-line options suitable for use
    with some compiler (depending on the two format strings passed in).
    """
    lib_opts = []

    for dir in library_dirs:
        lib_opts.append(compiler.library_dir_option(dir))

    for dir in runtime_library_dirs:
        opt = compiler.runtime_library_dir_option(dir)
        if isinstance(opt, list):
            lib_opts = lib_opts + opt
        else:
            lib_opts.append(opt)

    # XXX it's important that we *not* remove redundant library mentions!
    # sometimes you really do have to say "-lfoo -lbar -lfoo" in order to
    # resolve all symbols.  I just hope we never have to say "-lfoo obj.o
    # -lbar" to get things to work -- that's certainly a possibility, but a
    # pretty nasty way to arrange your C code.

    for lib in libraries:
        (lib_dir, lib_name) = os.path.split(lib)
        if lib_dir:
            lib_file = compiler.find_library_file([lib_dir], lib_name)
            if lib_file:
                lib_opts.append(lib_file)
            else:
                compiler.warn(
                    "no library file corresponding to " "'%s' found (skipping)" % lib
                )
        else:
            lib_opts.append(compiler.library_option(lib))
    return lib_opts
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/cmd.py0000644000175100001730000004270514467657412021203 0ustar00runnerdocker"""distutils.cmd

Provides the Command class, the base class for the command classes
in the distutils.command package.
"""

import sys
import os
import re
import logging

from .errors import DistutilsOptionError
from . import util, dir_util, file_util, archive_util, dep_util
from ._log import log


class Command:
    """Abstract base class for defining command classes, the "worker bees"
    of the Distutils.  A useful analogy for command classes is to think of
    them as subroutines with local variables called "options".  The options
    are "declared" in 'initialize_options()' and "defined" (given their
    final values, aka "finalized") in 'finalize_options()', both of which
    must be defined by every command class.  The distinction between the
    two is necessary because option values might come from the outside
    world (command line, config file, ...), and any options dependent on
    other options must be computed *after* these outside influences have
    been processed -- hence 'finalize_options()'.  The "body" of the
    subroutine, where it does all its work based on the values of its
    options, is the 'run()' method, which must also be implemented by every
    command class.
    """

    # 'sub_commands' formalizes the notion of a "family" of commands,
    # eg. "install" as the parent with sub-commands "install_lib",
    # "install_headers", etc.  The parent of a family of commands
    # defines 'sub_commands' as a class attribute; it's a list of
    #    (command_name : string, predicate : unbound_method | string | None)
    # tuples, where 'predicate' is a method of the parent command that
    # determines whether the corresponding command is applicable in the
    # current situation.  (Eg. we "install_headers" is only applicable if
    # we have any C header files to install.)  If 'predicate' is None,
    # that command is always applicable.
    #
    # 'sub_commands' is usually defined at the *end* of a class, because
    # predicates can be unbound methods, so they must already have been
    # defined.  The canonical example is the "install" command.
    sub_commands = []

    # -- Creation/initialization methods -------------------------------

    def __init__(self, dist):
        """Create and initialize a new Command object.  Most importantly,
        invokes the 'initialize_options()' method, which is the real
        initializer and depends on the actual command being
        instantiated.
        """
        # late import because of mutual dependence between these classes
        from distutils.dist import Distribution

        if not isinstance(dist, Distribution):
            raise TypeError("dist must be a Distribution instance")
        if self.__class__ is Command:
            raise RuntimeError("Command is an abstract class")

        self.distribution = dist
        self.initialize_options()

        # Per-command versions of the global flags, so that the user can
        # customize Distutils' behaviour command-by-command and let some
        # commands fall back on the Distribution's behaviour.  None means
        # "not defined, check self.distribution's copy", while 0 or 1 mean
        # false and true (duh).  Note that this means figuring out the real
        # value of each flag is a touch complicated -- hence "self._dry_run"
        # will be handled by __getattr__, below.
        # XXX This needs to be fixed.
        self._dry_run = None

        # verbose is largely ignored, but needs to be set for
        # backwards compatibility (I think)?
        self.verbose = dist.verbose

        # Some commands define a 'self.force' option to ignore file
        # timestamps, but methods defined *here* assume that
        # 'self.force' exists for all commands.  So define it here
        # just to be safe.
        self.force = None

        # The 'help' flag is just used for command-line parsing, so
        # none of that complicated bureaucracy is needed.
        self.help = 0

        # 'finalized' records whether or not 'finalize_options()' has been
        # called.  'finalize_options()' itself should not pay attention to
        # this flag: it is the business of 'ensure_finalized()', which
        # always calls 'finalize_options()', to respect/update it.
        self.finalized = 0

    # XXX A more explicit way to customize dry_run would be better.
    def __getattr__(self, attr):
        if attr == 'dry_run':
            myval = getattr(self, "_" + attr)
            if myval is None:
                return getattr(self.distribution, attr)
            else:
                return myval
        else:
            raise AttributeError(attr)

    def ensure_finalized(self):
        if not self.finalized:
            self.finalize_options()
        self.finalized = 1

    # Subclasses must define:
    #   initialize_options()
    #     provide default values for all options; may be customized by
    #     setup script, by options from config file(s), or by command-line
    #     options
    #   finalize_options()
    #     decide on the final values for all options; this is called
    #     after all possible intervention from the outside world
    #     (command-line, option file, etc.) has been processed
    #   run()
    #     run the command: do whatever it is we're here to do,
    #     controlled by the command's various option values

    def initialize_options(self):
        """Set default values for all the options that this command
        supports.  Note that these defaults may be overridden by other
        commands, by the setup script, by config files, or by the
        command-line.  Thus, this is not the place to code dependencies
        between options; generally, 'initialize_options()' implementations
        are just a bunch of "self.foo = None" assignments.

        This method must be implemented by all command classes.
        """
        raise RuntimeError(
            "abstract method -- subclass %s must override" % self.__class__
        )

    def finalize_options(self):
        """Set final values for all the options that this command supports.
        This is always called as late as possible, ie.  after any option
        assignments from the command-line or from other commands have been
        done.  Thus, this is the place to code option dependencies: if
        'foo' depends on 'bar', then it is safe to set 'foo' from 'bar' as
        long as 'foo' still has the same value it was assigned in
        'initialize_options()'.

        This method must be implemented by all command classes.
        """
        raise RuntimeError(
            "abstract method -- subclass %s must override" % self.__class__
        )

    def dump_options(self, header=None, indent=""):
        from distutils.fancy_getopt import longopt_xlate

        if header is None:
            header = "command options for '%s':" % self.get_command_name()
        self.announce(indent + header, level=logging.INFO)
        indent = indent + "  "
        for option, _, _ in self.user_options:
            option = option.translate(longopt_xlate)
            if option[-1] == "=":
                option = option[:-1]
            value = getattr(self, option)
            self.announce(indent + "{} = {}".format(option, value), level=logging.INFO)

    def run(self):
        """A command's raison d'etre: carry out the action it exists to
        perform, controlled by the options initialized in
        'initialize_options()', customized by other commands, the setup
        script, the command-line, and config files, and finalized in
        'finalize_options()'.  All terminal output and filesystem
        interaction should be done by 'run()'.

        This method must be implemented by all command classes.
        """
        raise RuntimeError(
            "abstract method -- subclass %s must override" % self.__class__
        )

    def announce(self, msg, level=logging.DEBUG):
        log.log(level, msg)

    def debug_print(self, msg):
        """Print 'msg' to stdout if the global DEBUG (taken from the
        DISTUTILS_DEBUG environment variable) flag is true.
        """
        from distutils.debug import DEBUG

        if DEBUG:
            print(msg)
            sys.stdout.flush()

    # -- Option validation methods -------------------------------------
    # (these are very handy in writing the 'finalize_options()' method)
    #
    # NB. the general philosophy here is to ensure that a particular option
    # value meets certain type and value constraints.  If not, we try to
    # force it into conformance (eg. if we expect a list but have a string,
    # split the string on comma and/or whitespace).  If we can't force the
    # option into conformance, raise DistutilsOptionError.  Thus, command
    # classes need do nothing more than (eg.)
    #   self.ensure_string_list('foo')
    # and they can be guaranteed that thereafter, self.foo will be
    # a list of strings.

    def _ensure_stringlike(self, option, what, default=None):
        val = getattr(self, option)
        if val is None:
            setattr(self, option, default)
            return default
        elif not isinstance(val, str):
            raise DistutilsOptionError(
                "'{}' must be a {} (got `{}`)".format(option, what, val)
            )
        return val

    def ensure_string(self, option, default=None):
        """Ensure that 'option' is a string; if not defined, set it to
        'default'.
        """
        self._ensure_stringlike(option, "string", default)

    def ensure_string_list(self, option):
        r"""Ensure that 'option' is a list of strings.  If 'option' is
        currently a string, we split it either on /,\s*/ or /\s+/, so
        "foo bar baz", "foo,bar,baz", and "foo,   bar baz" all become
        ["foo", "bar", "baz"].
        """
        val = getattr(self, option)
        if val is None:
            return
        elif isinstance(val, str):
            setattr(self, option, re.split(r',\s*|\s+', val))
        else:
            if isinstance(val, list):
                ok = all(isinstance(v, str) for v in val)
            else:
                ok = False
            if not ok:
                raise DistutilsOptionError(
                    "'{}' must be a list of strings (got {!r})".format(option, val)
                )

    def _ensure_tested_string(self, option, tester, what, error_fmt, default=None):
        val = self._ensure_stringlike(option, what, default)
        if val is not None and not tester(val):
            raise DistutilsOptionError(
                ("error in '%s' option: " + error_fmt) % (option, val)
            )

    def ensure_filename(self, option):
        """Ensure that 'option' is the name of an existing file."""
        self._ensure_tested_string(
            option, os.path.isfile, "filename", "'%s' does not exist or is not a file"
        )

    def ensure_dirname(self, option):
        self._ensure_tested_string(
            option,
            os.path.isdir,
            "directory name",
            "'%s' does not exist or is not a directory",
        )

    # -- Convenience methods for commands ------------------------------

    def get_command_name(self):
        if hasattr(self, 'command_name'):
            return self.command_name
        else:
            return self.__class__.__name__

    def set_undefined_options(self, src_cmd, *option_pairs):
        """Set the values of any "undefined" options from corresponding
        option values in some other command object.  "Undefined" here means
        "is None", which is the convention used to indicate that an option
        has not been changed between 'initialize_options()' and
        'finalize_options()'.  Usually called from 'finalize_options()' for
        options that depend on some other command rather than another
        option of the same command.  'src_cmd' is the other command from
        which option values will be taken (a command object will be created
        for it if necessary); the remaining arguments are
        '(src_option,dst_option)' tuples which mean "take the value of
        'src_option' in the 'src_cmd' command object, and copy it to
        'dst_option' in the current command object".
        """
        # Option_pairs: list of (src_option, dst_option) tuples
        src_cmd_obj = self.distribution.get_command_obj(src_cmd)
        src_cmd_obj.ensure_finalized()
        for src_option, dst_option in option_pairs:
            if getattr(self, dst_option) is None:
                setattr(self, dst_option, getattr(src_cmd_obj, src_option))

    def get_finalized_command(self, command, create=1):
        """Wrapper around Distribution's 'get_command_obj()' method: find
        (create if necessary and 'create' is true) the command object for
        'command', call its 'ensure_finalized()' method, and return the
        finalized command object.
        """
        cmd_obj = self.distribution.get_command_obj(command, create)
        cmd_obj.ensure_finalized()
        return cmd_obj

    # XXX rename to 'get_reinitialized_command()'? (should do the
    # same in dist.py, if so)
    def reinitialize_command(self, command, reinit_subcommands=0):
        return self.distribution.reinitialize_command(command, reinit_subcommands)

    def run_command(self, command):
        """Run some other command: uses the 'run_command()' method of
        Distribution, which creates and finalizes the command object if
        necessary and then invokes its 'run()' method.
        """
        self.distribution.run_command(command)

    def get_sub_commands(self):
        """Determine the sub-commands that are relevant in the current
        distribution (ie., that need to be run).  This is based on the
        'sub_commands' class attribute: each tuple in that list may include
        a method that we call to determine if the subcommand needs to be
        run for the current distribution.  Return a list of command names.
        """
        commands = []
        for cmd_name, method in self.sub_commands:
            if method is None or method(self):
                commands.append(cmd_name)
        return commands

    # -- External world manipulation -----------------------------------

    def warn(self, msg):
        log.warning("warning: %s: %s\n", self.get_command_name(), msg)

    def execute(self, func, args, msg=None, level=1):
        util.execute(func, args, msg, dry_run=self.dry_run)

    def mkpath(self, name, mode=0o777):
        dir_util.mkpath(name, mode, dry_run=self.dry_run)

    def copy_file(
        self, infile, outfile, preserve_mode=1, preserve_times=1, link=None, level=1
    ):
        """Copy a file respecting verbose, dry-run and force flags.  (The
        former two default to whatever is in the Distribution object, and
        the latter defaults to false for commands that don't define it.)"""
        return file_util.copy_file(
            infile,
            outfile,
            preserve_mode,
            preserve_times,
            not self.force,
            link,
            dry_run=self.dry_run,
        )

    def copy_tree(
        self,
        infile,
        outfile,
        preserve_mode=1,
        preserve_times=1,
        preserve_symlinks=0,
        level=1,
    ):
        """Copy an entire directory tree respecting verbose, dry-run,
        and force flags.
        """
        return dir_util.copy_tree(
            infile,
            outfile,
            preserve_mode,
            preserve_times,
            preserve_symlinks,
            not self.force,
            dry_run=self.dry_run,
        )

    def move_file(self, src, dst, level=1):
        """Move a file respecting dry-run flag."""
        return file_util.move_file(src, dst, dry_run=self.dry_run)

    def spawn(self, cmd, search_path=1, level=1):
        """Spawn an external command respecting dry-run flag."""
        from distutils.spawn import spawn

        spawn(cmd, search_path, dry_run=self.dry_run)

    def make_archive(
        self, base_name, format, root_dir=None, base_dir=None, owner=None, group=None
    ):
        return archive_util.make_archive(
            base_name,
            format,
            root_dir,
            base_dir,
            dry_run=self.dry_run,
            owner=owner,
            group=group,
        )

    def make_file(
        self, infiles, outfile, func, args, exec_msg=None, skip_msg=None, level=1
    ):
        """Special case of 'execute()' for operations that process one or
        more input files and generate one output file.  Works just like
        'execute()', except the operation is skipped and a different
        message printed if 'outfile' already exists and is newer than all
        files listed in 'infiles'.  If the command defined 'self.force',
        and it is true, then the command is unconditionally run -- does no
        timestamp checks.
        """
        if skip_msg is None:
            skip_msg = "skipping %s (inputs unchanged)" % outfile

        # Allow 'infiles' to be a single string
        if isinstance(infiles, str):
            infiles = (infiles,)
        elif not isinstance(infiles, (list, tuple)):
            raise TypeError("'infiles' must be a string, or a list or tuple of strings")

        if exec_msg is None:
            exec_msg = "generating {} from {}".format(outfile, ', '.join(infiles))

        # If 'outfile' must be regenerated (either because it doesn't
        # exist, is out-of-date, or the 'force' flag is true) then
        # perform the action that presumably regenerates it
        if self.force or dep_util.newer_group(infiles, outfile):
            self.execute(func, args, exec_msg, level)
        # Otherwise, print the "skip" message
        else:
            log.debug(skip_msg)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5195496
setuptools-68.1.2/setuptools/_distutils/command/0000755000175100001730000000000014467657444021501 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/__init__.py0000644000175100001730000000065614467657412023614 0ustar00runnerdocker"""distutils.command

Package containing implementation of all the standard Distutils
commands."""

__all__ = [  # noqa: F822
    'build',
    'build_py',
    'build_ext',
    'build_clib',
    'build_scripts',
    'clean',
    'install',
    'install_lib',
    'install_headers',
    'install_scripts',
    'install_data',
    'sdist',
    'register',
    'bdist',
    'bdist_dumb',
    'bdist_rpm',
    'check',
    'upload',
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/_framework_compat.py0000644000175100001730000000311614467657412025546 0ustar00runnerdocker"""
Backward compatibility for homebrew builds on macOS.
"""


import sys
import os
import functools
import subprocess
import sysconfig


@functools.lru_cache()
def enabled():
    """
    Only enabled for Python 3.9 framework homebrew builds
    except ensurepip and venv.
    """
    PY39 = (3, 9) < sys.version_info < (3, 10)
    framework = sys.platform == 'darwin' and sys._framework
    homebrew = "Cellar" in sysconfig.get_config_var('projectbase')
    venv = sys.prefix != sys.base_prefix
    ensurepip = os.environ.get("ENSUREPIP_OPTIONS")
    return PY39 and framework and homebrew and not venv and not ensurepip


schemes = dict(
    osx_framework_library=dict(
        stdlib='{installed_base}/{platlibdir}/python{py_version_short}',
        platstdlib='{platbase}/{platlibdir}/python{py_version_short}',
        purelib='{homebrew_prefix}/lib/python{py_version_short}/site-packages',
        platlib='{homebrew_prefix}/{platlibdir}/python{py_version_short}/site-packages',
        include='{installed_base}/include/python{py_version_short}{abiflags}',
        platinclude='{installed_platbase}/include/python{py_version_short}{abiflags}',
        scripts='{homebrew_prefix}/bin',
        data='{homebrew_prefix}',
    )
)


@functools.lru_cache()
def vars():
    if not enabled():
        return {}
    homebrew_prefix = subprocess.check_output(['brew', '--prefix'], text=True).strip()
    return locals()


def scheme(name):
    """
    Override the selected scheme for posix_prefix.
    """
    if not enabled() or not name.endswith('_prefix'):
        return name
    return 'osx_framework_library'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/bdist.py0000644000175100001730000001244014467657412023154 0ustar00runnerdocker"""distutils.command.bdist

Implements the Distutils 'bdist' command (create a built [binary]
distribution)."""

import os
import warnings

from ..core import Command
from ..errors import DistutilsPlatformError, DistutilsOptionError
from ..util import get_platform


def show_formats():
    """Print list of available formats (arguments to "--format" option)."""
    from ..fancy_getopt import FancyGetopt

    formats = []
    for format in bdist.format_commands:
        formats.append(("formats=" + format, None, bdist.format_commands[format][1]))
    pretty_printer = FancyGetopt(formats)
    pretty_printer.print_help("List of available distribution formats:")


class ListCompat(dict):
    # adapter to allow for Setuptools compatibility in format_commands
    def append(self, item):
        warnings.warn(
            """format_commands is now a dict. append is deprecated.""",
            DeprecationWarning,
            stacklevel=2,
        )


class bdist(Command):
    description = "create a built (binary) distribution"

    user_options = [
        ('bdist-base=', 'b', "temporary directory for creating built distributions"),
        (
            'plat-name=',
            'p',
            "platform name to embed in generated filenames "
            "(default: %s)" % get_platform(),
        ),
        ('formats=', None, "formats for distribution (comma-separated list)"),
        (
            'dist-dir=',
            'd',
            "directory to put final built distributions in " "[default: dist]",
        ),
        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
        (
            'owner=',
            'u',
            "Owner name used when creating a tar file" " [default: current user]",
        ),
        (
            'group=',
            'g',
            "Group name used when creating a tar file" " [default: current group]",
        ),
    ]

    boolean_options = ['skip-build']

    help_options = [
        ('help-formats', None, "lists available distribution formats", show_formats),
    ]

    # The following commands do not take a format option from bdist
    no_format_option = ('bdist_rpm',)

    # This won't do in reality: will need to distinguish RPM-ish Linux,
    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
    default_format = {'posix': 'gztar', 'nt': 'zip'}

    # Define commands in preferred order for the --help-formats option
    format_commands = ListCompat(
        {
            'rpm': ('bdist_rpm', "RPM distribution"),
            'gztar': ('bdist_dumb', "gzip'ed tar file"),
            'bztar': ('bdist_dumb', "bzip2'ed tar file"),
            'xztar': ('bdist_dumb', "xz'ed tar file"),
            'ztar': ('bdist_dumb', "compressed tar file"),
            'tar': ('bdist_dumb', "tar file"),
            'zip': ('bdist_dumb', "ZIP file"),
        }
    )

    # for compatibility until consumers only reference format_commands
    format_command = format_commands

    def initialize_options(self):
        self.bdist_base = None
        self.plat_name = None
        self.formats = None
        self.dist_dir = None
        self.skip_build = 0
        self.group = None
        self.owner = None

    def finalize_options(self):
        # have to finalize 'plat_name' before 'bdist_base'
        if self.plat_name is None:
            if self.skip_build:
                self.plat_name = get_platform()
            else:
                self.plat_name = self.get_finalized_command('build').plat_name

        # 'bdist_base' -- parent of per-built-distribution-format
        # temporary directories (eg. we'll probably have
        # "build/bdist./dumb", "build/bdist./rpm", etc.)
        if self.bdist_base is None:
            build_base = self.get_finalized_command('build').build_base
            self.bdist_base = os.path.join(build_base, 'bdist.' + self.plat_name)

        self.ensure_string_list('formats')
        if self.formats is None:
            try:
                self.formats = [self.default_format[os.name]]
            except KeyError:
                raise DistutilsPlatformError(
                    "don't know how to create built distributions "
                    "on platform %s" % os.name
                )

        if self.dist_dir is None:
            self.dist_dir = "dist"

    def run(self):
        # Figure out which sub-commands we need to run.
        commands = []
        for format in self.formats:
            try:
                commands.append(self.format_commands[format][0])
            except KeyError:
                raise DistutilsOptionError("invalid format '%s'" % format)

        # Reinitialize and run each command.
        for i in range(len(self.formats)):
            cmd_name = commands[i]
            sub_cmd = self.reinitialize_command(cmd_name)
            if cmd_name not in self.no_format_option:
                sub_cmd.format = self.formats[i]

            # passing the owner and group names for tar archiving
            if cmd_name == 'bdist_dumb':
                sub_cmd.owner = self.owner
                sub_cmd.group = self.group

            # If we're going to need to run this command again, tell it to
            # keep its temporary files around so subsequent runs go faster.
            if cmd_name in commands[i + 1 :]:
                sub_cmd.keep_temp = 1
            self.run_command(cmd_name)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/bdist_dumb.py0000644000175100001730000001107114467657412024162 0ustar00runnerdocker"""distutils.command.bdist_dumb

Implements the Distutils 'bdist_dumb' command (create a "dumb" built
distribution -- i.e., just an archive to be unpacked under $prefix or
$exec_prefix)."""

import os
from ..core import Command
from ..util import get_platform
from ..dir_util import remove_tree, ensure_relative
from ..errors import DistutilsPlatformError
from ..sysconfig import get_python_version
from distutils._log import log


class bdist_dumb(Command):
    description = "create a \"dumb\" built distribution"

    user_options = [
        ('bdist-dir=', 'd', "temporary directory for creating the distribution"),
        (
            'plat-name=',
            'p',
            "platform name to embed in generated filenames "
            "(default: %s)" % get_platform(),
        ),
        (
            'format=',
            'f',
            "archive format to create (tar, gztar, bztar, xztar, " "ztar, zip)",
        ),
        (
            'keep-temp',
            'k',
            "keep the pseudo-installation tree around after "
            + "creating the distribution archive",
        ),
        ('dist-dir=', 'd', "directory to put final built distributions in"),
        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
        (
            'relative',
            None,
            "build the archive using relative paths " "(default: false)",
        ),
        (
            'owner=',
            'u',
            "Owner name used when creating a tar file" " [default: current user]",
        ),
        (
            'group=',
            'g',
            "Group name used when creating a tar file" " [default: current group]",
        ),
    ]

    boolean_options = ['keep-temp', 'skip-build', 'relative']

    default_format = {'posix': 'gztar', 'nt': 'zip'}

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.format = None
        self.keep_temp = 0
        self.dist_dir = None
        self.skip_build = None
        self.relative = 0
        self.owner = None
        self.group = None

    def finalize_options(self):
        if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'dumb')

        if self.format is None:
            try:
                self.format = self.default_format[os.name]
            except KeyError:
                raise DistutilsPlatformError(
                    "don't know how to create dumb built distributions "
                    "on platform %s" % os.name
                )

        self.set_undefined_options(
            'bdist',
            ('dist_dir', 'dist_dir'),
            ('plat_name', 'plat_name'),
            ('skip_build', 'skip_build'),
        )

    def run(self):
        if not self.skip_build:
            self.run_command('build')

        install = self.reinitialize_command('install', reinit_subcommands=1)
        install.root = self.bdist_dir
        install.skip_build = self.skip_build
        install.warn_dir = 0

        log.info("installing to %s", self.bdist_dir)
        self.run_command('install')

        # And make an archive relative to the root of the
        # pseudo-installation tree.
        archive_basename = "{}.{}".format(
            self.distribution.get_fullname(), self.plat_name
        )

        pseudoinstall_root = os.path.join(self.dist_dir, archive_basename)
        if not self.relative:
            archive_root = self.bdist_dir
        else:
            if self.distribution.has_ext_modules() and (
                install.install_base != install.install_platbase
            ):
                raise DistutilsPlatformError(
                    "can't make a dumb built distribution where "
                    "base and platbase are different (%s, %s)"
                    % (repr(install.install_base), repr(install.install_platbase))
                )
            else:
                archive_root = os.path.join(
                    self.bdist_dir, ensure_relative(install.install_base)
                )

        # Make the archive
        filename = self.make_archive(
            pseudoinstall_root,
            self.format,
            root_dir=archive_root,
            owner=self.owner,
            group=self.group,
        )
        if self.distribution.has_ext_modules():
            pyversion = get_python_version()
        else:
            pyversion = 'any'
        self.distribution.dist_files.append(('bdist_dumb', pyversion, filename))

        if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/bdist_rpm.py0000644000175100001730000005277514467657412024051 0ustar00runnerdocker"""distutils.command.bdist_rpm

Implements the Distutils 'bdist_rpm' command (create RPM source and binary
distributions)."""

import subprocess
import sys
import os

from ..core import Command
from ..debug import DEBUG
from ..file_util import write_file
from ..errors import (
    DistutilsOptionError,
    DistutilsPlatformError,
    DistutilsFileError,
    DistutilsExecError,
)
from ..sysconfig import get_python_version
from distutils._log import log


class bdist_rpm(Command):
    description = "create an RPM distribution"

    user_options = [
        ('bdist-base=', None, "base directory for creating built distributions"),
        (
            'rpm-base=',
            None,
            "base directory for creating RPMs (defaults to \"rpm\" under "
            "--bdist-base; must be specified for RPM 2)",
        ),
        (
            'dist-dir=',
            'd',
            "directory to put final RPM files in " "(and .spec files if --spec-only)",
        ),
        (
            'python=',
            None,
            "path to Python interpreter to hard-code in the .spec file "
            "(default: \"python\")",
        ),
        (
            'fix-python',
            None,
            "hard-code the exact path to the current Python interpreter in "
            "the .spec file",
        ),
        ('spec-only', None, "only regenerate spec file"),
        ('source-only', None, "only generate source RPM"),
        ('binary-only', None, "only generate binary RPM"),
        ('use-bzip2', None, "use bzip2 instead of gzip to create source distribution"),
        # More meta-data: too RPM-specific to put in the setup script,
        # but needs to go in the .spec file -- so we make these options
        # to "bdist_rpm".  The idea is that packagers would put this
        # info in setup.cfg, although they are of course free to
        # supply it on the command line.
        (
            'distribution-name=',
            None,
            "name of the (Linux) distribution to which this "
            "RPM applies (*not* the name of the module distribution!)",
        ),
        ('group=', None, "package classification [default: \"Development/Libraries\"]"),
        ('release=', None, "RPM release number"),
        ('serial=', None, "RPM serial number"),
        (
            'vendor=',
            None,
            "RPM \"vendor\" (eg. \"Joe Blow \") "
            "[default: maintainer or author from setup script]",
        ),
        (
            'packager=',
            None,
            "RPM packager (eg. \"Jane Doe \") " "[default: vendor]",
        ),
        ('doc-files=', None, "list of documentation files (space or comma-separated)"),
        ('changelog=', None, "RPM changelog"),
        ('icon=', None, "name of icon file"),
        ('provides=', None, "capabilities provided by this package"),
        ('requires=', None, "capabilities required by this package"),
        ('conflicts=', None, "capabilities which conflict with this package"),
        ('build-requires=', None, "capabilities required to build this package"),
        ('obsoletes=', None, "capabilities made obsolete by this package"),
        ('no-autoreq', None, "do not automatically calculate dependencies"),
        # Actions to take when building RPM
        ('keep-temp', 'k', "don't clean up RPM build directory"),
        ('no-keep-temp', None, "clean up RPM build directory [default]"),
        (
            'use-rpm-opt-flags',
            None,
            "compile with RPM_OPT_FLAGS when building from source RPM",
        ),
        ('no-rpm-opt-flags', None, "do not pass any RPM CFLAGS to compiler"),
        ('rpm3-mode', None, "RPM 3 compatibility mode (default)"),
        ('rpm2-mode', None, "RPM 2 compatibility mode"),
        # Add the hooks necessary for specifying custom scripts
        ('prep-script=', None, "Specify a script for the PREP phase of RPM building"),
        ('build-script=', None, "Specify a script for the BUILD phase of RPM building"),
        (
            'pre-install=',
            None,
            "Specify a script for the pre-INSTALL phase of RPM building",
        ),
        (
            'install-script=',
            None,
            "Specify a script for the INSTALL phase of RPM building",
        ),
        (
            'post-install=',
            None,
            "Specify a script for the post-INSTALL phase of RPM building",
        ),
        (
            'pre-uninstall=',
            None,
            "Specify a script for the pre-UNINSTALL phase of RPM building",
        ),
        (
            'post-uninstall=',
            None,
            "Specify a script for the post-UNINSTALL phase of RPM building",
        ),
        ('clean-script=', None, "Specify a script for the CLEAN phase of RPM building"),
        (
            'verify-script=',
            None,
            "Specify a script for the VERIFY phase of the RPM build",
        ),
        # Allow a packager to explicitly force an architecture
        ('force-arch=', None, "Force an architecture onto the RPM build process"),
        ('quiet', 'q', "Run the INSTALL phase of RPM building in quiet mode"),
    ]

    boolean_options = [
        'keep-temp',
        'use-rpm-opt-flags',
        'rpm3-mode',
        'no-autoreq',
        'quiet',
    ]

    negative_opt = {
        'no-keep-temp': 'keep-temp',
        'no-rpm-opt-flags': 'use-rpm-opt-flags',
        'rpm2-mode': 'rpm3-mode',
    }

    def initialize_options(self):
        self.bdist_base = None
        self.rpm_base = None
        self.dist_dir = None
        self.python = None
        self.fix_python = None
        self.spec_only = None
        self.binary_only = None
        self.source_only = None
        self.use_bzip2 = None

        self.distribution_name = None
        self.group = None
        self.release = None
        self.serial = None
        self.vendor = None
        self.packager = None
        self.doc_files = None
        self.changelog = None
        self.icon = None

        self.prep_script = None
        self.build_script = None
        self.install_script = None
        self.clean_script = None
        self.verify_script = None
        self.pre_install = None
        self.post_install = None
        self.pre_uninstall = None
        self.post_uninstall = None
        self.prep = None
        self.provides = None
        self.requires = None
        self.conflicts = None
        self.build_requires = None
        self.obsoletes = None

        self.keep_temp = 0
        self.use_rpm_opt_flags = 1
        self.rpm3_mode = 1
        self.no_autoreq = 0

        self.force_arch = None
        self.quiet = 0

    def finalize_options(self):
        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))
        if self.rpm_base is None:
            if not self.rpm3_mode:
                raise DistutilsOptionError("you must specify --rpm-base in RPM 2 mode")
            self.rpm_base = os.path.join(self.bdist_base, "rpm")

        if self.python is None:
            if self.fix_python:
                self.python = sys.executable
            else:
                self.python = "python3"
        elif self.fix_python:
            raise DistutilsOptionError(
                "--python and --fix-python are mutually exclusive options"
            )

        if os.name != 'posix':
            raise DistutilsPlatformError(
                "don't know how to create RPM " "distributions on platform %s" % os.name
            )
        if self.binary_only and self.source_only:
            raise DistutilsOptionError(
                "cannot supply both '--source-only' and '--binary-only'"
            )

        # don't pass CFLAGS to pure python distributions
        if not self.distribution.has_ext_modules():
            self.use_rpm_opt_flags = 0

        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))
        self.finalize_package_data()

    def finalize_package_data(self):
        self.ensure_string('group', "Development/Libraries")
        self.ensure_string(
            'vendor',
            "%s <%s>"
            % (self.distribution.get_contact(), self.distribution.get_contact_email()),
        )
        self.ensure_string('packager')
        self.ensure_string_list('doc_files')
        if isinstance(self.doc_files, list):
            for readme in ('README', 'README.txt'):
                if os.path.exists(readme) and readme not in self.doc_files:
                    self.doc_files.append(readme)

        self.ensure_string('release', "1")
        self.ensure_string('serial')  # should it be an int?

        self.ensure_string('distribution_name')

        self.ensure_string('changelog')
        # Format changelog correctly
        self.changelog = self._format_changelog(self.changelog)

        self.ensure_filename('icon')

        self.ensure_filename('prep_script')
        self.ensure_filename('build_script')
        self.ensure_filename('install_script')
        self.ensure_filename('clean_script')
        self.ensure_filename('verify_script')
        self.ensure_filename('pre_install')
        self.ensure_filename('post_install')
        self.ensure_filename('pre_uninstall')
        self.ensure_filename('post_uninstall')

        # XXX don't forget we punted on summaries and descriptions -- they
        # should be handled here eventually!

        # Now *this* is some meta-data that belongs in the setup script...
        self.ensure_string_list('provides')
        self.ensure_string_list('requires')
        self.ensure_string_list('conflicts')
        self.ensure_string_list('build_requires')
        self.ensure_string_list('obsoletes')

        self.ensure_string('force_arch')

    def run(self):  # noqa: C901
        if DEBUG:
            print("before _get_package_data():")
            print("vendor =", self.vendor)
            print("packager =", self.packager)
            print("doc_files =", self.doc_files)
            print("changelog =", self.changelog)

        # make directories
        if self.spec_only:
            spec_dir = self.dist_dir
            self.mkpath(spec_dir)
        else:
            rpm_dir = {}
            for d in ('SOURCES', 'SPECS', 'BUILD', 'RPMS', 'SRPMS'):
                rpm_dir[d] = os.path.join(self.rpm_base, d)
                self.mkpath(rpm_dir[d])
            spec_dir = rpm_dir['SPECS']

        # Spec file goes into 'dist_dir' if '--spec-only specified',
        # build/rpm. otherwise.
        spec_path = os.path.join(spec_dir, "%s.spec" % self.distribution.get_name())
        self.execute(
            write_file, (spec_path, self._make_spec_file()), "writing '%s'" % spec_path
        )

        if self.spec_only:  # stop if requested
            return

        # Make a source distribution and copy to SOURCES directory with
        # optional icon.
        saved_dist_files = self.distribution.dist_files[:]
        sdist = self.reinitialize_command('sdist')
        if self.use_bzip2:
            sdist.formats = ['bztar']
        else:
            sdist.formats = ['gztar']
        self.run_command('sdist')
        self.distribution.dist_files = saved_dist_files

        source = sdist.get_archive_files()[0]
        source_dir = rpm_dir['SOURCES']
        self.copy_file(source, source_dir)

        if self.icon:
            if os.path.exists(self.icon):
                self.copy_file(self.icon, source_dir)
            else:
                raise DistutilsFileError("icon file '%s' does not exist" % self.icon)

        # build package
        log.info("building RPMs")
        rpm_cmd = ['rpmbuild']

        if self.source_only:  # what kind of RPMs?
            rpm_cmd.append('-bs')
        elif self.binary_only:
            rpm_cmd.append('-bb')
        else:
            rpm_cmd.append('-ba')
        rpm_cmd.extend(['--define', '__python %s' % self.python])
        if self.rpm3_mode:
            rpm_cmd.extend(['--define', '_topdir %s' % os.path.abspath(self.rpm_base)])
        if not self.keep_temp:
            rpm_cmd.append('--clean')

        if self.quiet:
            rpm_cmd.append('--quiet')

        rpm_cmd.append(spec_path)
        # Determine the binary rpm names that should be built out of this spec
        # file
        # Note that some of these may not be really built (if the file
        # list is empty)
        nvr_string = "%{name}-%{version}-%{release}"
        src_rpm = nvr_string + ".src.rpm"
        non_src_rpm = "%{arch}/" + nvr_string + ".%{arch}.rpm"
        q_cmd = r"rpm -q --qf '{} {}\n' --specfile '{}'".format(
            src_rpm,
            non_src_rpm,
            spec_path,
        )

        out = os.popen(q_cmd)
        try:
            binary_rpms = []
            source_rpm = None
            while True:
                line = out.readline()
                if not line:
                    break
                ell = line.strip().split()
                assert len(ell) == 2
                binary_rpms.append(ell[1])
                # The source rpm is named after the first entry in the spec file
                if source_rpm is None:
                    source_rpm = ell[0]

            status = out.close()
            if status:
                raise DistutilsExecError("Failed to execute: %s" % repr(q_cmd))

        finally:
            out.close()

        self.spawn(rpm_cmd)

        if not self.dry_run:
            if self.distribution.has_ext_modules():
                pyversion = get_python_version()
            else:
                pyversion = 'any'

            if not self.binary_only:
                srpm = os.path.join(rpm_dir['SRPMS'], source_rpm)
                assert os.path.exists(srpm)
                self.move_file(srpm, self.dist_dir)
                filename = os.path.join(self.dist_dir, source_rpm)
                self.distribution.dist_files.append(('bdist_rpm', pyversion, filename))

            if not self.source_only:
                for rpm in binary_rpms:
                    rpm = os.path.join(rpm_dir['RPMS'], rpm)
                    if os.path.exists(rpm):
                        self.move_file(rpm, self.dist_dir)
                        filename = os.path.join(self.dist_dir, os.path.basename(rpm))
                        self.distribution.dist_files.append(
                            ('bdist_rpm', pyversion, filename)
                        )

    def _dist_path(self, path):
        return os.path.join(self.dist_dir, os.path.basename(path))

    def _make_spec_file(self):  # noqa: C901
        """Generate the text of an RPM spec file and return it as a
        list of strings (one per line).
        """
        # definitions and headers
        spec_file = [
            '%define name ' + self.distribution.get_name(),
            '%define version ' + self.distribution.get_version().replace('-', '_'),
            '%define unmangled_version ' + self.distribution.get_version(),
            '%define release ' + self.release.replace('-', '_'),
            '',
            'Summary: ' + (self.distribution.get_description() or "UNKNOWN"),
        ]

        # Workaround for #14443 which affects some RPM based systems such as
        # RHEL6 (and probably derivatives)
        vendor_hook = subprocess.getoutput('rpm --eval %{__os_install_post}')
        # Generate a potential replacement value for __os_install_post (whilst
        # normalizing the whitespace to simplify the test for whether the
        # invocation of brp-python-bytecompile passes in __python):
        vendor_hook = '\n'.join(
            ['  %s \\' % line.strip() for line in vendor_hook.splitlines()]
        )
        problem = "brp-python-bytecompile \\\n"
        fixed = "brp-python-bytecompile %{__python} \\\n"
        fixed_hook = vendor_hook.replace(problem, fixed)
        if fixed_hook != vendor_hook:
            spec_file.append('# Workaround for http://bugs.python.org/issue14443')
            spec_file.append('%define __os_install_post ' + fixed_hook + '\n')

        # put locale summaries into spec file
        # XXX not supported for now (hard to put a dictionary
        # in a config file -- arg!)
        # for locale in self.summaries.keys():
        #    spec_file.append('Summary(%s): %s' % (locale,
        #                                          self.summaries[locale]))

        spec_file.extend(
            [
                'Name: %{name}',
                'Version: %{version}',
                'Release: %{release}',
            ]
        )

        # XXX yuck! this filename is available from the "sdist" command,
        # but only after it has run: and we create the spec file before
        # running "sdist", in case of --spec-only.
        if self.use_bzip2:
            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.bz2')
        else:
            spec_file.append('Source0: %{name}-%{unmangled_version}.tar.gz')

        spec_file.extend(
            [
                'License: ' + (self.distribution.get_license() or "UNKNOWN"),
                'Group: ' + self.group,
                'BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-buildroot',
                'Prefix: %{_prefix}',
            ]
        )

        if not self.force_arch:
            # noarch if no extension modules
            if not self.distribution.has_ext_modules():
                spec_file.append('BuildArch: noarch')
        else:
            spec_file.append('BuildArch: %s' % self.force_arch)

        for field in (
            'Vendor',
            'Packager',
            'Provides',
            'Requires',
            'Conflicts',
            'Obsoletes',
        ):
            val = getattr(self, field.lower())
            if isinstance(val, list):
                spec_file.append('{}: {}'.format(field, ' '.join(val)))
            elif val is not None:
                spec_file.append('{}: {}'.format(field, val))

        if self.distribution.get_url():
            spec_file.append('Url: ' + self.distribution.get_url())

        if self.distribution_name:
            spec_file.append('Distribution: ' + self.distribution_name)

        if self.build_requires:
            spec_file.append('BuildRequires: ' + ' '.join(self.build_requires))

        if self.icon:
            spec_file.append('Icon: ' + os.path.basename(self.icon))

        if self.no_autoreq:
            spec_file.append('AutoReq: 0')

        spec_file.extend(
            [
                '',
                '%description',
                self.distribution.get_long_description() or "",
            ]
        )

        # put locale descriptions into spec file
        # XXX again, suppressed because config file syntax doesn't
        # easily support this ;-(
        # for locale in self.descriptions.keys():
        #    spec_file.extend([
        #        '',
        #        '%description -l ' + locale,
        #        self.descriptions[locale],
        #        ])

        # rpm scripts
        # figure out default build script
        def_setup_call = "{} {}".format(self.python, os.path.basename(sys.argv[0]))
        def_build = "%s build" % def_setup_call
        if self.use_rpm_opt_flags:
            def_build = 'env CFLAGS="$RPM_OPT_FLAGS" ' + def_build

        # insert contents of files

        # XXX this is kind of misleading: user-supplied options are files
        # that we open and interpolate into the spec file, but the defaults
        # are just text that we drop in as-is.  Hmmm.

        install_cmd = (
            '%s install -O1 --root=$RPM_BUILD_ROOT ' '--record=INSTALLED_FILES'
        ) % def_setup_call

        script_options = [
            ('prep', 'prep_script', "%setup -n %{name}-%{unmangled_version}"),
            ('build', 'build_script', def_build),
            ('install', 'install_script', install_cmd),
            ('clean', 'clean_script', "rm -rf $RPM_BUILD_ROOT"),
            ('verifyscript', 'verify_script', None),
            ('pre', 'pre_install', None),
            ('post', 'post_install', None),
            ('preun', 'pre_uninstall', None),
            ('postun', 'post_uninstall', None),
        ]

        for rpm_opt, attr, default in script_options:
            # Insert contents of file referred to, if no file is referred to
            # use 'default' as contents of script
            val = getattr(self, attr)
            if val or default:
                spec_file.extend(
                    [
                        '',
                        '%' + rpm_opt,
                    ]
                )
                if val:
                    with open(val) as f:
                        spec_file.extend(f.read().split('\n'))
                else:
                    spec_file.append(default)

        # files section
        spec_file.extend(
            [
                '',
                '%files -f INSTALLED_FILES',
                '%defattr(-,root,root)',
            ]
        )

        if self.doc_files:
            spec_file.append('%doc ' + ' '.join(self.doc_files))

        if self.changelog:
            spec_file.extend(
                [
                    '',
                    '%changelog',
                ]
            )
            spec_file.extend(self.changelog)

        return spec_file

    def _format_changelog(self, changelog):
        """Format the changelog correctly and convert it to a list of strings"""
        if not changelog:
            return changelog
        new_changelog = []
        for line in changelog.strip().split('\n'):
            line = line.strip()
            if line[0] == '*':
                new_changelog.extend(['', line])
            elif line[0] == '-':
                new_changelog.append(line)
            else:
                new_changelog.append('  ' + line)

        # strip trailing newline inserted by first changelog entry
        if not new_changelog[0]:
            del new_changelog[0]

        return new_changelog
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/build.py0000644000175100001730000001272014467657412023147 0ustar00runnerdocker"""distutils.command.build

Implements the Distutils 'build' command."""

import sys
import os
from ..core import Command
from ..errors import DistutilsOptionError
from ..util import get_platform


def show_compilers():
    from ..ccompiler import show_compilers

    show_compilers()


class build(Command):
    description = "build everything needed to install"

    user_options = [
        ('build-base=', 'b', "base directory for build library"),
        ('build-purelib=', None, "build directory for platform-neutral distributions"),
        ('build-platlib=', None, "build directory for platform-specific distributions"),
        (
            'build-lib=',
            None,
            "build directory for all distribution (defaults to either "
            + "build-purelib or build-platlib",
        ),
        ('build-scripts=', None, "build directory for scripts"),
        ('build-temp=', 't', "temporary build directory"),
        (
            'plat-name=',
            'p',
            "platform name to build for, if supported "
            "(default: %s)" % get_platform(),
        ),
        ('compiler=', 'c', "specify the compiler type"),
        ('parallel=', 'j', "number of parallel build jobs"),
        ('debug', 'g', "compile extensions and libraries with debugging information"),
        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
        ('executable=', 'e', "specify final destination interpreter path (build.py)"),
    ]

    boolean_options = ['debug', 'force']

    help_options = [
        ('help-compiler', None, "list available compilers", show_compilers),
    ]

    def initialize_options(self):
        self.build_base = 'build'
        # these are decided only after 'build_base' has its final value
        # (unless overridden by the user or client)
        self.build_purelib = None
        self.build_platlib = None
        self.build_lib = None
        self.build_temp = None
        self.build_scripts = None
        self.compiler = None
        self.plat_name = None
        self.debug = None
        self.force = 0
        self.executable = None
        self.parallel = None

    def finalize_options(self):  # noqa: C901
        if self.plat_name is None:
            self.plat_name = get_platform()
        else:
            # plat-name only supported for windows (other platforms are
            # supported via ./configure flags, if at all).  Avoid misleading
            # other platforms.
            if os.name != 'nt':
                raise DistutilsOptionError(
                    "--plat-name only supported on Windows (try "
                    "using './configure --help' on your platform)"
                )

        plat_specifier = ".{}-{}".format(self.plat_name, sys.implementation.cache_tag)

        # Make it so Python 2.x and Python 2.x with --with-pydebug don't
        # share the same build directories. Doing so confuses the build
        # process for C modules
        if hasattr(sys, 'gettotalrefcount'):
            plat_specifier += '-pydebug'

        # 'build_purelib' and 'build_platlib' just default to 'lib' and
        # 'lib.' under the base build directory.  We only use one of
        # them for a given distribution, though --
        if self.build_purelib is None:
            self.build_purelib = os.path.join(self.build_base, 'lib')
        if self.build_platlib is None:
            self.build_platlib = os.path.join(self.build_base, 'lib' + plat_specifier)

        # 'build_lib' is the actual directory that we will use for this
        # particular module distribution -- if user didn't supply it, pick
        # one of 'build_purelib' or 'build_platlib'.
        if self.build_lib is None:
            if self.distribution.has_ext_modules():
                self.build_lib = self.build_platlib
            else:
                self.build_lib = self.build_purelib

        # 'build_temp' -- temporary directory for compiler turds,
        # "build/temp."
        if self.build_temp is None:
            self.build_temp = os.path.join(self.build_base, 'temp' + plat_specifier)
        if self.build_scripts is None:
            self.build_scripts = os.path.join(
                self.build_base, 'scripts-%d.%d' % sys.version_info[:2]
            )

        if self.executable is None and sys.executable:
            self.executable = os.path.normpath(sys.executable)

        if isinstance(self.parallel, str):
            try:
                self.parallel = int(self.parallel)
            except ValueError:
                raise DistutilsOptionError("parallel should be an integer")

    def run(self):
        # Run all relevant sub-commands.  This will be some subset of:
        #  - build_py      - pure Python modules
        #  - build_clib    - standalone C libraries
        #  - build_ext     - Python extensions
        #  - build_scripts - (Python) scripts
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

    # -- Predicates for the sub-command list ---------------------------

    def has_pure_modules(self):
        return self.distribution.has_pure_modules()

    def has_c_libraries(self):
        return self.distribution.has_c_libraries()

    def has_ext_modules(self):
        return self.distribution.has_ext_modules()

    def has_scripts(self):
        return self.distribution.has_scripts()

    sub_commands = [
        ('build_py', has_pure_modules),
        ('build_clib', has_c_libraries),
        ('build_ext', has_ext_modules),
        ('build_scripts', has_scripts),
    ]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/build_clib.py0000644000175100001730000001700414467657412024140 0ustar00runnerdocker"""distutils.command.build_clib

Implements the Distutils 'build_clib' command, to build a C/C++ library
that is included in the module distribution and needed by an extension
module."""


# XXX this module has *lots* of code ripped-off quite transparently from
# build_ext.py -- not surprisingly really, as the work required to build
# a static library from a collection of C source files is not really all
# that different from what's required to build a shared object file from
# a collection of C source files.  Nevertheless, I haven't done the
# necessary refactoring to account for the overlap in code between the
# two modules, mainly because a number of subtle details changed in the
# cut 'n paste.  Sigh.

import os
from ..core import Command
from ..errors import DistutilsSetupError
from ..sysconfig import customize_compiler
from distutils._log import log


def show_compilers():
    from ..ccompiler import show_compilers

    show_compilers()


class build_clib(Command):
    description = "build C/C++ libraries used by Python extensions"

    user_options = [
        ('build-clib=', 'b', "directory to build C/C++ libraries to"),
        ('build-temp=', 't', "directory to put temporary build by-products"),
        ('debug', 'g', "compile with debugging information"),
        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
        ('compiler=', 'c', "specify the compiler type"),
    ]

    boolean_options = ['debug', 'force']

    help_options = [
        ('help-compiler', None, "list available compilers", show_compilers),
    ]

    def initialize_options(self):
        self.build_clib = None
        self.build_temp = None

        # List of libraries to build
        self.libraries = None

        # Compilation options for all libraries
        self.include_dirs = None
        self.define = None
        self.undef = None
        self.debug = None
        self.force = 0
        self.compiler = None

    def finalize_options(self):
        # This might be confusing: both build-clib and build-temp default
        # to build-temp as defined by the "build" command.  This is because
        # I think that C libraries are really just temporary build
        # by-products, at least from the point of view of building Python
        # extensions -- but I want to keep my options open.
        self.set_undefined_options(
            'build',
            ('build_temp', 'build_clib'),
            ('build_temp', 'build_temp'),
            ('compiler', 'compiler'),
            ('debug', 'debug'),
            ('force', 'force'),
        )

        self.libraries = self.distribution.libraries
        if self.libraries:
            self.check_library_list(self.libraries)

        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        if isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

        # XXX same as for build_ext -- what about 'self.define' and
        # 'self.undef' ?

    def run(self):
        if not self.libraries:
            return

        # Yech -- this is cut 'n pasted from build_ext.py!
        from ..ccompiler import new_compiler

        self.compiler = new_compiler(
            compiler=self.compiler, dry_run=self.dry_run, force=self.force
        )
        customize_compiler(self.compiler)

        if self.include_dirs is not None:
            self.compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for name, value in self.define:
                self.compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                self.compiler.undefine_macro(macro)

        self.build_libraries(self.libraries)

    def check_library_list(self, libraries):
        """Ensure that the list of libraries is valid.

        `library` is presumably provided as a command option 'libraries'.
        This method checks that it is a list of 2-tuples, where the tuples
        are (library_name, build_info_dict).

        Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        """
        if not isinstance(libraries, list):
            raise DistutilsSetupError("'libraries' option must be a list of tuples")

        for lib in libraries:
            if not isinstance(lib, tuple) and len(lib) != 2:
                raise DistutilsSetupError("each element of 'libraries' must a 2-tuple")

            name, build_info = lib

            if not isinstance(name, str):
                raise DistutilsSetupError(
                    "first element of each tuple in 'libraries' "
                    "must be a string (the library name)"
                )

            if '/' in name or (os.sep != '/' and os.sep in name):
                raise DistutilsSetupError(
                    "bad library name '%s': "
                    "may not contain directory separators" % lib[0]
                )

            if not isinstance(build_info, dict):
                raise DistutilsSetupError(
                    "second element of each tuple in 'libraries' "
                    "must be a dictionary (build info)"
                )

    def get_library_names(self):
        # Assume the library list is valid -- 'check_library_list()' is
        # called from 'finalize_options()', so it should be!
        if not self.libraries:
            return None

        lib_names = []
        for lib_name, build_info in self.libraries:
            lib_names.append(lib_name)
        return lib_names

    def get_source_files(self):
        self.check_library_list(self.libraries)
        filenames = []
        for lib_name, build_info in self.libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'sources' must be present and must be "
                    "a list of source filenames" % lib_name
                )

            filenames.extend(sources)
        return filenames

    def build_libraries(self, libraries):
        for lib_name, build_info in libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'sources' must be present and must be "
                    "a list of source filenames" % lib_name
                )
            sources = list(sources)

            log.info("building '%s' library", lib_name)

            # First, compile the source code to object files in the library
            # directory.  (This should probably change to putting object
            # files in a temporary build directory.)
            macros = build_info.get('macros')
            include_dirs = build_info.get('include_dirs')
            objects = self.compiler.compile(
                sources,
                output_dir=self.build_temp,
                macros=macros,
                include_dirs=include_dirs,
                debug=self.debug,
            )

            # Now "link" the object files together into a static library.
            # (On Unix at least, this isn't really linking -- it just
            # builds an archive.  Whatever.)
            self.compiler.create_static_lib(
                objects, lib_name, output_dir=self.build_clib, debug=self.debug
            )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/build_ext.py0000644000175100001730000007541714467657412024043 0ustar00runnerdocker"""distutils.command.build_ext

Implements the Distutils 'build_ext' command, for building extension
modules (currently limited to C extensions, should accommodate C++
extensions ASAP)."""

import contextlib
import os
import re
import sys
from ..core import Command
from ..errors import (
    DistutilsOptionError,
    DistutilsSetupError,
    CCompilerError,
    DistutilsError,
    CompileError,
    DistutilsPlatformError,
)
from ..sysconfig import customize_compiler, get_python_version
from ..sysconfig import get_config_h_filename
from ..dep_util import newer_group
from ..extension import Extension
from ..util import get_platform
from distutils._log import log
from . import py37compat

from site import USER_BASE

# An extension name is just a dot-separated list of Python NAMEs (ie.
# the same as a fully-qualified module name).
extension_name_re = re.compile(r'^[a-zA-Z_][a-zA-Z_0-9]*(\.[a-zA-Z_][a-zA-Z_0-9]*)*$')


def show_compilers():
    from ..ccompiler import show_compilers

    show_compilers()


class build_ext(Command):
    description = "build C/C++ extensions (compile/link to build directory)"

    # XXX thoughts on how to deal with complex command-line options like
    # these, i.e. how to make it so fancy_getopt can suck them off the
    # command line and make it look like setup.py defined the appropriate
    # lists of tuples of what-have-you.
    #   - each command needs a callback to process its command-line options
    #   - Command.__init__() needs access to its share of the whole
    #     command line (must ultimately come from
    #     Distribution.parse_command_line())
    #   - it then calls the current command class' option-parsing
    #     callback to deal with weird options like -D, which have to
    #     parse the option text and churn out some custom data
    #     structure
    #   - that data structure (in this case, a list of 2-tuples)
    #     will then be present in the command object by the time
    #     we get to finalize_options() (i.e. the constructor
    #     takes care of both command-line and client options
    #     in between initialize_options() and finalize_options())

    sep_by = " (separated by '%s')" % os.pathsep
    user_options = [
        ('build-lib=', 'b', "directory for compiled extension modules"),
        ('build-temp=', 't', "directory for temporary files (build by-products)"),
        (
            'plat-name=',
            'p',
            "platform name to cross-compile for, if supported "
            "(default: %s)" % get_platform(),
        ),
        (
            'inplace',
            'i',
            "ignore build-lib and put compiled extensions into the source "
            + "directory alongside your pure Python modules",
        ),
        (
            'include-dirs=',
            'I',
            "list of directories to search for header files" + sep_by,
        ),
        ('define=', 'D', "C preprocessor macros to define"),
        ('undef=', 'U', "C preprocessor macros to undefine"),
        ('libraries=', 'l', "external C libraries to link with"),
        (
            'library-dirs=',
            'L',
            "directories to search for external C libraries" + sep_by,
        ),
        ('rpath=', 'R', "directories to search for shared C libraries at runtime"),
        ('link-objects=', 'O', "extra explicit link objects to include in the link"),
        ('debug', 'g', "compile/link with debugging information"),
        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
        ('compiler=', 'c', "specify the compiler type"),
        ('parallel=', 'j', "number of parallel build jobs"),
        ('swig-cpp', None, "make SWIG create C++ files (default is C)"),
        ('swig-opts=', None, "list of SWIG command line options"),
        ('swig=', None, "path to the SWIG executable"),
        ('user', None, "add user include, library and rpath"),
    ]

    boolean_options = ['inplace', 'debug', 'force', 'swig-cpp', 'user']

    help_options = [
        ('help-compiler', None, "list available compilers", show_compilers),
    ]

    def initialize_options(self):
        self.extensions = None
        self.build_lib = None
        self.plat_name = None
        self.build_temp = None
        self.inplace = 0
        self.package = None

        self.include_dirs = None
        self.define = None
        self.undef = None
        self.libraries = None
        self.library_dirs = None
        self.rpath = None
        self.link_objects = None
        self.debug = None
        self.force = None
        self.compiler = None
        self.swig = None
        self.swig_cpp = None
        self.swig_opts = None
        self.user = None
        self.parallel = None

    def finalize_options(self):  # noqa: C901
        from distutils import sysconfig

        self.set_undefined_options(
            'build',
            ('build_lib', 'build_lib'),
            ('build_temp', 'build_temp'),
            ('compiler', 'compiler'),
            ('debug', 'debug'),
            ('force', 'force'),
            ('parallel', 'parallel'),
            ('plat_name', 'plat_name'),
        )

        if self.package is None:
            self.package = self.distribution.ext_package

        self.extensions = self.distribution.ext_modules

        # Make sure Python's include directories (for Python.h, pyconfig.h,
        # etc.) are in the include search path.
        py_include = sysconfig.get_python_inc()
        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        if isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

        # If in a virtualenv, add its include directory
        # Issue 16116
        if sys.exec_prefix != sys.base_exec_prefix:
            self.include_dirs.append(os.path.join(sys.exec_prefix, 'include'))

        # Put the Python "system" include dir at the end, so that
        # any local include dirs take precedence.
        self.include_dirs.extend(py_include.split(os.path.pathsep))
        if plat_py_include != py_include:
            self.include_dirs.extend(plat_py_include.split(os.path.pathsep))

        self.ensure_string_list('libraries')
        self.ensure_string_list('link_objects')

        # Life is easier if we're not forever checking for None, so
        # simplify these options to empty lists if unset
        if self.libraries is None:
            self.libraries = []
        if self.library_dirs is None:
            self.library_dirs = []
        elif isinstance(self.library_dirs, str):
            self.library_dirs = self.library_dirs.split(os.pathsep)

        if self.rpath is None:
            self.rpath = []
        elif isinstance(self.rpath, str):
            self.rpath = self.rpath.split(os.pathsep)

        # for extensions under windows use different directories
        # for Release and Debug builds.
        # also Python's library directory must be appended to library_dirs
        if os.name == 'nt':
            # the 'libs' directory is for binary installs - we assume that
            # must be the *native* platform.  But we don't really support
            # cross-compiling via a binary install anyway, so we let it go.
            self.library_dirs.append(os.path.join(sys.exec_prefix, 'libs'))
            if sys.base_exec_prefix != sys.prefix:  # Issue 16116
                self.library_dirs.append(os.path.join(sys.base_exec_prefix, 'libs'))
            if self.debug:
                self.build_temp = os.path.join(self.build_temp, "Debug")
            else:
                self.build_temp = os.path.join(self.build_temp, "Release")

            # Append the source distribution include and library directories,
            # this allows distutils on windows to work in the source tree
            self.include_dirs.append(os.path.dirname(get_config_h_filename()))
            self.library_dirs.append(sys.base_exec_prefix)

            # Use the .lib files for the correct architecture
            if self.plat_name == 'win32':
                suffix = 'win32'
            else:
                # win-amd64
                suffix = self.plat_name[4:]
            new_lib = os.path.join(sys.exec_prefix, 'PCbuild')
            if suffix:
                new_lib = os.path.join(new_lib, suffix)
            self.library_dirs.append(new_lib)

        # For extensions under Cygwin, Python's library directory must be
        # appended to library_dirs
        if sys.platform[:6] == 'cygwin':
            if not sysconfig.python_build:
                # building third party extensions
                self.library_dirs.append(
                    os.path.join(
                        sys.prefix, "lib", "python" + get_python_version(), "config"
                    )
                )
            else:
                # building python standard extensions
                self.library_dirs.append('.')

        # For building extensions with a shared Python library,
        # Python's library directory must be appended to library_dirs
        # See Issues: #1600860, #4366
        if sysconfig.get_config_var('Py_ENABLE_SHARED'):
            if not sysconfig.python_build:
                # building third party extensions
                self.library_dirs.append(sysconfig.get_config_var('LIBDIR'))
            else:
                # building python standard extensions
                self.library_dirs.append('.')

        # The argument parsing will result in self.define being a string, but
        # it has to be a list of 2-tuples.  All the preprocessor symbols
        # specified by the 'define' option will be set to '1'.  Multiple
        # symbols can be separated with commas.

        if self.define:
            defines = self.define.split(',')
            self.define = [(symbol, '1') for symbol in defines]

        # The option for macros to undefine is also a string from the
        # option parsing, but has to be a list.  Multiple symbols can also
        # be separated with commas here.
        if self.undef:
            self.undef = self.undef.split(',')

        if self.swig_opts is None:
            self.swig_opts = []
        else:
            self.swig_opts = self.swig_opts.split(' ')

        # Finally add the user include and library directories if requested
        if self.user:
            user_include = os.path.join(USER_BASE, "include")
            user_lib = os.path.join(USER_BASE, "lib")
            if os.path.isdir(user_include):
                self.include_dirs.append(user_include)
            if os.path.isdir(user_lib):
                self.library_dirs.append(user_lib)
                self.rpath.append(user_lib)

        if isinstance(self.parallel, str):
            try:
                self.parallel = int(self.parallel)
            except ValueError:
                raise DistutilsOptionError("parallel should be an integer")

    def run(self):  # noqa: C901
        from ..ccompiler import new_compiler

        # 'self.extensions', as supplied by setup.py, is a list of
        # Extension instances.  See the documentation for Extension (in
        # distutils.extension) for details.
        #
        # For backwards compatibility with Distutils 0.8.2 and earlier, we
        # also allow the 'extensions' list to be a list of tuples:
        #    (ext_name, build_info)
        # where build_info is a dictionary containing everything that
        # Extension instances do except the name, with a few things being
        # differently named.  We convert these 2-tuples to Extension
        # instances as needed.

        if not self.extensions:
            return

        # If we were asked to build any C/C++ libraries, make sure that the
        # directory where we put them is in the library search path for
        # linking extensions.
        if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command('build_clib')
            self.libraries.extend(build_clib.get_library_names() or [])
            self.library_dirs.append(build_clib.build_clib)

        # Setup the CCompiler object that we'll use to do all the
        # compiling and linking
        self.compiler = new_compiler(
            compiler=self.compiler,
            verbose=self.verbose,
            dry_run=self.dry_run,
            force=self.force,
        )
        customize_compiler(self.compiler)
        # If we are cross-compiling, init the compiler now (if we are not
        # cross-compiling, init would not hurt, but people may rely on
        # late initialization of compiler even if they shouldn't...)
        if os.name == 'nt' and self.plat_name != get_platform():
            self.compiler.initialize(self.plat_name)

        # And make sure that any compile/link-related options (which might
        # come from the command-line or from the setup script) are set in
        # that CCompiler object -- that way, they automatically apply to
        # all compiling and linking done here.
        if self.include_dirs is not None:
            self.compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for name, value in self.define:
                self.compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                self.compiler.undefine_macro(macro)
        if self.libraries is not None:
            self.compiler.set_libraries(self.libraries)
        if self.library_dirs is not None:
            self.compiler.set_library_dirs(self.library_dirs)
        if self.rpath is not None:
            self.compiler.set_runtime_library_dirs(self.rpath)
        if self.link_objects is not None:
            self.compiler.set_link_objects(self.link_objects)

        # Now actually compile and link everything.
        self.build_extensions()

    def check_extensions_list(self, extensions):  # noqa: C901
        """Ensure that the list of extensions (presumably provided as a
        command option 'extensions') is valid, i.e. it is a list of
        Extension objects.  We also support the old-style list of 2-tuples,
        where the tuples are (ext_name, build_info), which are converted to
        Extension instances here.

        Raise DistutilsSetupError if the structure is invalid anywhere;
        just returns otherwise.
        """
        if not isinstance(extensions, list):
            raise DistutilsSetupError(
                "'ext_modules' option must be a list of Extension instances"
            )

        for i, ext in enumerate(extensions):
            if isinstance(ext, Extension):
                continue  # OK! (assume type-checking done
                # by Extension constructor)

            if not isinstance(ext, tuple) or len(ext) != 2:
                raise DistutilsSetupError(
                    "each element of 'ext_modules' option must be an "
                    "Extension instance or 2-tuple"
                )

            ext_name, build_info = ext

            log.warning(
                "old-style (ext_name, build_info) tuple found in "
                "ext_modules for extension '%s' "
                "-- please convert to Extension instance",
                ext_name,
            )

            if not (isinstance(ext_name, str) and extension_name_re.match(ext_name)):
                raise DistutilsSetupError(
                    "first element of each tuple in 'ext_modules' "
                    "must be the extension name (a string)"
                )

            if not isinstance(build_info, dict):
                raise DistutilsSetupError(
                    "second element of each tuple in 'ext_modules' "
                    "must be a dictionary (build info)"
                )

            # OK, the (ext_name, build_info) dict is type-safe: convert it
            # to an Extension instance.
            ext = Extension(ext_name, build_info['sources'])

            # Easy stuff: one-to-one mapping from dict elements to
            # instance attributes.
            for key in (
                'include_dirs',
                'library_dirs',
                'libraries',
                'extra_objects',
                'extra_compile_args',
                'extra_link_args',
            ):
                val = build_info.get(key)
                if val is not None:
                    setattr(ext, key, val)

            # Medium-easy stuff: same syntax/semantics, different names.
            ext.runtime_library_dirs = build_info.get('rpath')
            if 'def_file' in build_info:
                log.warning(
                    "'def_file' element of build info dict " "no longer supported"
                )

            # Non-trivial stuff: 'macros' split into 'define_macros'
            # and 'undef_macros'.
            macros = build_info.get('macros')
            if macros:
                ext.define_macros = []
                ext.undef_macros = []
                for macro in macros:
                    if not (isinstance(macro, tuple) and len(macro) in (1, 2)):
                        raise DistutilsSetupError(
                            "'macros' element of build info dict "
                            "must be 1- or 2-tuple"
                        )
                    if len(macro) == 1:
                        ext.undef_macros.append(macro[0])
                    elif len(macro) == 2:
                        ext.define_macros.append(macro)

            extensions[i] = ext

    def get_source_files(self):
        self.check_extensions_list(self.extensions)
        filenames = []

        # Wouldn't it be neat if we knew the names of header files too...
        for ext in self.extensions:
            filenames.extend(ext.sources)
        return filenames

    def get_outputs(self):
        # Sanity check the 'extensions' list -- can't assume this is being
        # done in the same run as a 'build_extensions()' call (in fact, we
        # can probably assume that it *isn't*!).
        self.check_extensions_list(self.extensions)

        # And build the list of output (built) filenames.  Note that this
        # ignores the 'inplace' flag, and assumes everything goes in the
        # "build" tree.
        outputs = []
        for ext in self.extensions:
            outputs.append(self.get_ext_fullpath(ext.name))
        return outputs

    def build_extensions(self):
        # First, sanity-check the 'extensions' list
        self.check_extensions_list(self.extensions)
        if self.parallel:
            self._build_extensions_parallel()
        else:
            self._build_extensions_serial()

    def _build_extensions_parallel(self):
        workers = self.parallel
        if self.parallel is True:
            workers = os.cpu_count()  # may return None
        try:
            from concurrent.futures import ThreadPoolExecutor
        except ImportError:
            workers = None

        if workers is None:
            self._build_extensions_serial()
            return

        with ThreadPoolExecutor(max_workers=workers) as executor:
            futures = [
                executor.submit(self.build_extension, ext) for ext in self.extensions
            ]
            for ext, fut in zip(self.extensions, futures):
                with self._filter_build_errors(ext):
                    fut.result()

    def _build_extensions_serial(self):
        for ext in self.extensions:
            with self._filter_build_errors(ext):
                self.build_extension(ext)

    @contextlib.contextmanager
    def _filter_build_errors(self, ext):
        try:
            yield
        except (CCompilerError, DistutilsError, CompileError) as e:
            if not ext.optional:
                raise
            self.warn('building extension "{}" failed: {}'.format(ext.name, e))

    def build_extension(self, ext):
        sources = ext.sources
        if sources is None or not isinstance(sources, (list, tuple)):
            raise DistutilsSetupError(
                "in 'ext_modules' option (extension '%s'), "
                "'sources' must be present and must be "
                "a list of source filenames" % ext.name
            )
        # sort to make the resulting .so file build reproducible
        sources = sorted(sources)

        ext_path = self.get_ext_fullpath(ext.name)
        depends = sources + ext.depends
        if not (self.force or newer_group(depends, ext_path, 'newer')):
            log.debug("skipping '%s' extension (up-to-date)", ext.name)
            return
        else:
            log.info("building '%s' extension", ext.name)

        # First, scan the sources for SWIG definition files (.i), run
        # SWIG on 'em to create .c files, and modify the sources list
        # accordingly.
        sources = self.swig_sources(sources, ext)

        # Next, compile the source code to object files.

        # XXX not honouring 'define_macros' or 'undef_macros' -- the
        # CCompiler API needs to change to accommodate this, and I
        # want to do one thing at a time!

        # Two possible sources for extra compiler arguments:
        #   - 'extra_compile_args' in Extension object
        #   - CFLAGS environment variable (not particularly
        #     elegant, but people seem to expect it and I
        #     guess it's useful)
        # The environment variable should take precedence, and
        # any sensible compiler will give precedence to later
        # command line args.  Hence we combine them in order:
        extra_args = ext.extra_compile_args or []

        macros = ext.define_macros[:]
        for undef in ext.undef_macros:
            macros.append((undef,))

        objects = self.compiler.compile(
            sources,
            output_dir=self.build_temp,
            macros=macros,
            include_dirs=ext.include_dirs,
            debug=self.debug,
            extra_postargs=extra_args,
            depends=ext.depends,
        )

        # XXX outdated variable, kept here in case third-part code
        # needs it.
        self._built_objects = objects[:]

        # Now link the object files together into a "shared object" --
        # of course, first we have to figure out all the other things
        # that go into the mix.
        if ext.extra_objects:
            objects.extend(ext.extra_objects)
        extra_args = ext.extra_link_args or []

        # Detect target language, if not provided
        language = ext.language or self.compiler.detect_language(sources)

        self.compiler.link_shared_object(
            objects,
            ext_path,
            libraries=self.get_libraries(ext),
            library_dirs=ext.library_dirs,
            runtime_library_dirs=ext.runtime_library_dirs,
            extra_postargs=extra_args,
            export_symbols=self.get_export_symbols(ext),
            debug=self.debug,
            build_temp=self.build_temp,
            target_lang=language,
        )

    def swig_sources(self, sources, extension):
        """Walk the list of source files in 'sources', looking for SWIG
        interface (.i) files.  Run SWIG on all that are found, and
        return a modified 'sources' list with SWIG source files replaced
        by the generated C (or C++) files.
        """
        new_sources = []
        swig_sources = []
        swig_targets = {}

        # XXX this drops generated C/C++ files into the source tree, which
        # is fine for developers who want to distribute the generated
        # source -- but there should be an option to put SWIG output in
        # the temp dir.

        if self.swig_cpp:
            log.warning("--swig-cpp is deprecated - use --swig-opts=-c++")

        if (
            self.swig_cpp
            or ('-c++' in self.swig_opts)
            or ('-c++' in extension.swig_opts)
        ):
            target_ext = '.cpp'
        else:
            target_ext = '.c'

        for source in sources:
            (base, ext) = os.path.splitext(source)
            if ext == ".i":  # SWIG interface file
                new_sources.append(base + '_wrap' + target_ext)
                swig_sources.append(source)
                swig_targets[source] = new_sources[-1]
            else:
                new_sources.append(source)

        if not swig_sources:
            return new_sources

        swig = self.swig or self.find_swig()
        swig_cmd = [swig, "-python"]
        swig_cmd.extend(self.swig_opts)
        if self.swig_cpp:
            swig_cmd.append("-c++")

        # Do not override commandline arguments
        if not self.swig_opts:
            for o in extension.swig_opts:
                swig_cmd.append(o)

        for source in swig_sources:
            target = swig_targets[source]
            log.info("swigging %s to %s", source, target)
            self.spawn(swig_cmd + ["-o", target, source])

        return new_sources

    def find_swig(self):
        """Return the name of the SWIG executable.  On Unix, this is
        just "swig" -- it should be in the PATH.  Tries a bit harder on
        Windows.
        """
        if os.name == "posix":
            return "swig"
        elif os.name == "nt":
            # Look for SWIG in its standard installation directory on
            # Windows (or so I presume!).  If we find it there, great;
            # if not, act like Unix and assume it's in the PATH.
            for vers in ("1.3", "1.2", "1.1"):
                fn = os.path.join("c:\\swig%s" % vers, "swig.exe")
                if os.path.isfile(fn):
                    return fn
            else:
                return "swig.exe"
        else:
            raise DistutilsPlatformError(
                "I don't know how to find (much less run) SWIG "
                "on platform '%s'" % os.name
            )

    # -- Name generators -----------------------------------------------
    # (extension names, filenames, whatever)
    def get_ext_fullpath(self, ext_name):
        """Returns the path of the filename for a given extension.

        The file is located in `build_lib` or directly in the package
        (inplace option).
        """
        fullname = self.get_ext_fullname(ext_name)
        modpath = fullname.split('.')
        filename = self.get_ext_filename(modpath[-1])

        if not self.inplace:
            # no further work needed
            # returning :
            #   build_dir/package/path/filename
            filename = os.path.join(*modpath[:-1] + [filename])
            return os.path.join(self.build_lib, filename)

        # the inplace option requires to find the package directory
        # using the build_py command for that
        package = '.'.join(modpath[0:-1])
        build_py = self.get_finalized_command('build_py')
        package_dir = os.path.abspath(build_py.get_package_dir(package))

        # returning
        #   package_dir/filename
        return os.path.join(package_dir, filename)

    def get_ext_fullname(self, ext_name):
        """Returns the fullname of a given extension name.

        Adds the `package.` prefix"""
        if self.package is None:
            return ext_name
        else:
            return self.package + '.' + ext_name

    def get_ext_filename(self, ext_name):
        r"""Convert the name of an extension (eg. "foo.bar") into the name
        of the file from which it will be loaded (eg. "foo/bar.so", or
        "foo\bar.pyd").
        """
        from ..sysconfig import get_config_var

        ext_path = ext_name.split('.')
        ext_suffix = get_config_var('EXT_SUFFIX')
        return os.path.join(*ext_path) + ext_suffix

    def get_export_symbols(self, ext):
        """Return the list of symbols that a shared extension has to
        export.  This either uses 'ext.export_symbols' or, if it's not
        provided, "PyInit_" + module_name.  Only relevant on Windows, where
        the .pyd file (DLL) must export the module "PyInit_" function.
        """
        name = ext.name.split('.')[-1]
        try:
            # Unicode module name support as defined in PEP-489
            # https://peps.python.org/pep-0489/#export-hook-name
            name.encode('ascii')
        except UnicodeEncodeError:
            suffix = 'U_' + name.encode('punycode').replace(b'-', b'_').decode('ascii')
        else:
            suffix = "_" + name

        initfunc_name = "PyInit" + suffix
        if initfunc_name not in ext.export_symbols:
            ext.export_symbols.append(initfunc_name)
        return ext.export_symbols

    def get_libraries(self, ext):  # noqa: C901
        """Return the list of libraries to link against when building a
        shared extension.  On most platforms, this is just 'ext.libraries';
        on Windows, we add the Python library (eg. python20.dll).
        """
        # The python library is always needed on Windows.  For MSVC, this
        # is redundant, since the library is mentioned in a pragma in
        # pyconfig.h that MSVC groks.  The other Windows compilers all seem
        # to need it mentioned explicitly, though, so that's what we do.
        # Append '_d' to the python import library on debug builds.
        if sys.platform == "win32":
            from .._msvccompiler import MSVCCompiler

            if not isinstance(self.compiler, MSVCCompiler):
                template = "python%d%d"
                if self.debug:
                    template = template + '_d'
                pythonlib = template % (
                    sys.hexversion >> 24,
                    (sys.hexversion >> 16) & 0xFF,
                )
                # don't extend ext.libraries, it may be shared with other
                # extensions, it is a reference to the original list
                return ext.libraries + [pythonlib]
        else:
            # On Android only the main executable and LD_PRELOADs are considered
            # to be RTLD_GLOBAL, all the dependencies of the main executable
            # remain RTLD_LOCAL and so the shared libraries must be linked with
            # libpython when python is built with a shared python library (issue
            # bpo-21536).
            # On Cygwin (and if required, other POSIX-like platforms based on
            # Windows like MinGW) it is simply necessary that all symbols in
            # shared libraries are resolved at link time.
            from ..sysconfig import get_config_var

            link_libpython = False
            if get_config_var('Py_ENABLE_SHARED'):
                # A native build on an Android device or on Cygwin
                if hasattr(sys, 'getandroidapilevel'):
                    link_libpython = True
                elif sys.platform == 'cygwin':
                    link_libpython = True
                elif '_PYTHON_HOST_PLATFORM' in os.environ:
                    # We are cross-compiling for one of the relevant platforms
                    if get_config_var('ANDROID_API_LEVEL') != 0:
                        link_libpython = True
                    elif get_config_var('MACHDEP') == 'cygwin':
                        link_libpython = True

            if link_libpython:
                ldversion = get_config_var('LDVERSION')
                return ext.libraries + ['python' + ldversion]

        return ext.libraries + py37compat.pythonlib()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/build_py.py0000644000175100001730000004023114467657412023655 0ustar00runnerdocker"""distutils.command.build_py

Implements the Distutils 'build_py' command."""

import os
import importlib.util
import sys
import glob

from ..core import Command
from ..errors import DistutilsOptionError, DistutilsFileError
from ..util import convert_path
from distutils._log import log


class build_py(Command):
    description = "\"build\" pure Python modules (copy to build directory)"

    user_options = [
        ('build-lib=', 'd', "directory to \"build\" (copy) to"),
        ('compile', 'c', "compile .py to .pyc"),
        ('no-compile', None, "don't compile .py files [default]"),
        (
            'optimize=',
            'O',
            "also compile with optimization: -O1 for \"python -O\", "
            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
        ),
        ('force', 'f', "forcibly build everything (ignore file timestamps)"),
    ]

    boolean_options = ['compile', 'force']
    negative_opt = {'no-compile': 'compile'}

    def initialize_options(self):
        self.build_lib = None
        self.py_modules = None
        self.package = None
        self.package_data = None
        self.package_dir = None
        self.compile = 0
        self.optimize = 0
        self.force = None

    def finalize_options(self):
        self.set_undefined_options(
            'build', ('build_lib', 'build_lib'), ('force', 'force')
        )

        # Get the distribution options that are aliases for build_py
        # options -- list of packages and list of modules.
        self.packages = self.distribution.packages
        self.py_modules = self.distribution.py_modules
        self.package_data = self.distribution.package_data
        self.package_dir = {}
        if self.distribution.package_dir:
            for name, path in self.distribution.package_dir.items():
                self.package_dir[name] = convert_path(path)
        self.data_files = self.get_data_files()

        # Ick, copied straight from install_lib.py (fancy_getopt needs a
        # type system!  Hell, *everything* needs a type system!!!)
        if not isinstance(self.optimize, int):
            try:
                self.optimize = int(self.optimize)
                assert 0 <= self.optimize <= 2
            except (ValueError, AssertionError):
                raise DistutilsOptionError("optimize must be 0, 1, or 2")

    def run(self):
        # XXX copy_file by default preserves atime and mtime.  IMHO this is
        # the right thing to do, but perhaps it should be an option -- in
        # particular, a site administrator might want installed files to
        # reflect the time of installation rather than the last
        # modification time before the installed release.

        # XXX copy_file by default preserves mode, which appears to be the
        # wrong thing to do: if a file is read-only in the working
        # directory, we want it to be installed read/write so that the next
        # installation of the same module distribution can overwrite it
        # without problems.  (This might be a Unix-specific issue.)  Thus
        # we turn off 'preserve_mode' when copying to the build directory,
        # since the build directory is supposed to be exactly what the
        # installation will look like (ie. we preserve mode when
        # installing).

        # Two options control which modules will be installed: 'packages'
        # and 'py_modules'.  The former lets us work with whole packages, not
        # specifying individual modules at all; the latter is for
        # specifying modules one-at-a-time.

        if self.py_modules:
            self.build_modules()
        if self.packages:
            self.build_packages()
            self.build_package_data()

        self.byte_compile(self.get_outputs(include_bytecode=0))

    def get_data_files(self):
        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
        data = []
        if not self.packages:
            return data
        for package in self.packages:
            # Locate package source directory
            src_dir = self.get_package_dir(package)

            # Compute package build directory
            build_dir = os.path.join(*([self.build_lib] + package.split('.')))

            # Length of path to strip from found files
            plen = 0
            if src_dir:
                plen = len(src_dir) + 1

            # Strip directory from globbed filenames
            filenames = [file[plen:] for file in self.find_data_files(package, src_dir)]
            data.append((package, src_dir, build_dir, filenames))
        return data

    def find_data_files(self, package, src_dir):
        """Return filenames for package's data files in 'src_dir'"""
        globs = self.package_data.get('', []) + self.package_data.get(package, [])
        files = []
        for pattern in globs:
            # Each pattern has to be converted to a platform-specific path
            filelist = glob.glob(
                os.path.join(glob.escape(src_dir), convert_path(pattern))
            )
            # Files that match more than one pattern are only added once
            files.extend(
                [fn for fn in filelist if fn not in files and os.path.isfile(fn)]
            )
        return files

    def build_package_data(self):
        """Copy data files into build directory"""
        for package, src_dir, build_dir, filenames in self.data_files:
            for filename in filenames:
                target = os.path.join(build_dir, filename)
                self.mkpath(os.path.dirname(target))
                self.copy_file(
                    os.path.join(src_dir, filename), target, preserve_mode=False
                )

    def get_package_dir(self, package):
        """Return the directory, relative to the top of the source
        distribution, where package 'package' should be found
        (at least according to the 'package_dir' option, if any)."""
        path = package.split('.')

        if not self.package_dir:
            if path:
                return os.path.join(*path)
            else:
                return ''
        else:
            tail = []
            while path:
                try:
                    pdir = self.package_dir['.'.join(path)]
                except KeyError:
                    tail.insert(0, path[-1])
                    del path[-1]
                else:
                    tail.insert(0, pdir)
                    return os.path.join(*tail)
            else:
                # Oops, got all the way through 'path' without finding a
                # match in package_dir.  If package_dir defines a directory
                # for the root (nameless) package, then fallback on it;
                # otherwise, we might as well have not consulted
                # package_dir at all, as we just use the directory implied
                # by 'tail' (which should be the same as the original value
                # of 'path' at this point).
                pdir = self.package_dir.get('')
                if pdir is not None:
                    tail.insert(0, pdir)

                if tail:
                    return os.path.join(*tail)
                else:
                    return ''

    def check_package(self, package, package_dir):
        # Empty dir name means current directory, which we can probably
        # assume exists.  Also, os.path.exists and isdir don't know about
        # my "empty string means current dir" convention, so we have to
        # circumvent them.
        if package_dir != "":
            if not os.path.exists(package_dir):
                raise DistutilsFileError(
                    "package directory '%s' does not exist" % package_dir
                )
            if not os.path.isdir(package_dir):
                raise DistutilsFileError(
                    "supposed package directory '%s' exists, "
                    "but is not a directory" % package_dir
                )

        # Directories without __init__.py are namespace packages (PEP 420).
        if package:
            init_py = os.path.join(package_dir, "__init__.py")
            if os.path.isfile(init_py):
                return init_py

        # Either not in a package at all (__init__.py not expected), or
        # __init__.py doesn't exist -- so don't return the filename.
        return None

    def check_module(self, module, module_file):
        if not os.path.isfile(module_file):
            log.warning("file %s (for module %s) not found", module_file, module)
            return False
        else:
            return True

    def find_package_modules(self, package, package_dir):
        self.check_package(package, package_dir)
        module_files = glob.glob(os.path.join(glob.escape(package_dir), "*.py"))
        modules = []
        setup_script = os.path.abspath(self.distribution.script_name)

        for f in module_files:
            abs_f = os.path.abspath(f)
            if abs_f != setup_script:
                module = os.path.splitext(os.path.basename(f))[0]
                modules.append((package, module, f))
            else:
                self.debug_print("excluding %s" % setup_script)
        return modules

    def find_modules(self):
        """Finds individually-specified Python modules, ie. those listed by
        module name in 'self.py_modules'.  Returns a list of tuples (package,
        module_base, filename): 'package' is a tuple of the path through
        package-space to the module; 'module_base' is the bare (no
        packages, no dots) module name, and 'filename' is the path to the
        ".py" file (relative to the distribution root) that implements the
        module.
        """
        # Map package names to tuples of useful info about the package:
        #    (package_dir, checked)
        # package_dir - the directory where we'll find source files for
        #   this package
        # checked - true if we have checked that the package directory
        #   is valid (exists, contains __init__.py, ... ?)
        packages = {}

        # List of (package, module, filename) tuples to return
        modules = []

        # We treat modules-in-packages almost the same as toplevel modules,
        # just the "package" for a toplevel is empty (either an empty
        # string or empty list, depending on context).  Differences:
        #   - don't check for __init__.py in directory for empty package
        for module in self.py_modules:
            path = module.split('.')
            package = '.'.join(path[0:-1])
            module_base = path[-1]

            try:
                (package_dir, checked) = packages[package]
            except KeyError:
                package_dir = self.get_package_dir(package)
                checked = 0

            if not checked:
                init_py = self.check_package(package, package_dir)
                packages[package] = (package_dir, 1)
                if init_py:
                    modules.append((package, "__init__", init_py))

            # XXX perhaps we should also check for just .pyc files
            # (so greedy closed-source bastards can distribute Python
            # modules too)
            module_file = os.path.join(package_dir, module_base + ".py")
            if not self.check_module(module, module_file):
                continue

            modules.append((package, module_base, module_file))

        return modules

    def find_all_modules(self):
        """Compute the list of all modules that will be built, whether
        they are specified one-module-at-a-time ('self.py_modules') or
        by whole packages ('self.packages').  Return a list of tuples
        (package, module, module_file), just like 'find_modules()' and
        'find_package_modules()' do."""
        modules = []
        if self.py_modules:
            modules.extend(self.find_modules())
        if self.packages:
            for package in self.packages:
                package_dir = self.get_package_dir(package)
                m = self.find_package_modules(package, package_dir)
                modules.extend(m)
        return modules

    def get_source_files(self):
        return [module[-1] for module in self.find_all_modules()]

    def get_module_outfile(self, build_dir, package, module):
        outfile_path = [build_dir] + list(package) + [module + ".py"]
        return os.path.join(*outfile_path)

    def get_outputs(self, include_bytecode=1):
        modules = self.find_all_modules()
        outputs = []
        for package, module, module_file in modules:
            package = package.split('.')
            filename = self.get_module_outfile(self.build_lib, package, module)
            outputs.append(filename)
            if include_bytecode:
                if self.compile:
                    outputs.append(
                        importlib.util.cache_from_source(filename, optimization='')
                    )
                if self.optimize > 0:
                    outputs.append(
                        importlib.util.cache_from_source(
                            filename, optimization=self.optimize
                        )
                    )

        outputs += [
            os.path.join(build_dir, filename)
            for package, src_dir, build_dir, filenames in self.data_files
            for filename in filenames
        ]

        return outputs

    def build_module(self, module, module_file, package):
        if isinstance(package, str):
            package = package.split('.')
        elif not isinstance(package, (list, tuple)):
            raise TypeError(
                "'package' must be a string (dot-separated), list, or tuple"
            )

        # Now put the module source file into the "build" area -- this is
        # easy, we just copy it somewhere under self.build_lib (the build
        # directory for Python source).
        outfile = self.get_module_outfile(self.build_lib, package, module)
        dir = os.path.dirname(outfile)
        self.mkpath(dir)
        return self.copy_file(module_file, outfile, preserve_mode=0)

    def build_modules(self):
        modules = self.find_modules()
        for package, module, module_file in modules:
            # Now "build" the module -- ie. copy the source file to
            # self.build_lib (the build directory for Python source).
            # (Actually, it gets copied to the directory for this package
            # under self.build_lib.)
            self.build_module(module, module_file, package)

    def build_packages(self):
        for package in self.packages:
            # Get list of (package, module, module_file) tuples based on
            # scanning the package directory.  'package' is only included
            # in the tuple so that 'find_modules()' and
            # 'find_package_tuples()' have a consistent interface; it's
            # ignored here (apart from a sanity check).  Also, 'module' is
            # the *unqualified* module name (ie. no dots, no package -- we
            # already know its package!), and 'module_file' is the path to
            # the .py file, relative to the current directory
            # (ie. including 'package_dir').
            package_dir = self.get_package_dir(package)
            modules = self.find_package_modules(package, package_dir)

            # Now loop over the modules we found, "building" each one (just
            # copy it to self.build_lib).
            for package_, module, module_file in modules:
                assert package == package_
                self.build_module(module, module_file, package)

    def byte_compile(self, files):
        if sys.dont_write_bytecode:
            self.warn('byte-compiling is disabled, skipping.')
            return

        from ..util import byte_compile

        prefix = self.build_lib
        if prefix[-1] != os.sep:
            prefix = prefix + os.sep

        # XXX this code is essentially the same as the 'byte_compile()
        # method of the "install_lib" command, except for the determination
        # of the 'prefix' string.  Hmmm.
        if self.compile:
            byte_compile(
                files, optimize=0, force=self.force, prefix=prefix, dry_run=self.dry_run
            )
        if self.optimize > 0:
            byte_compile(
                files,
                optimize=self.optimize,
                force=self.force,
                prefix=prefix,
                dry_run=self.dry_run,
            )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/build_scripts.py0000644000175100001730000001274414467657412024724 0ustar00runnerdocker"""distutils.command.build_scripts

Implements the Distutils 'build_scripts' command."""

import os
import re
from stat import ST_MODE
from distutils import sysconfig
from ..core import Command
from ..dep_util import newer
from ..util import convert_path
from distutils._log import log
import tokenize

shebang_pattern = re.compile('^#!.*python[0-9.]*([ \t].*)?$')
"""
Pattern matching a Python interpreter indicated in first line of a script.
"""

# for Setuptools compatibility
first_line_re = shebang_pattern


class build_scripts(Command):
    description = "\"build\" scripts (copy and fixup #! line)"

    user_options = [
        ('build-dir=', 'd', "directory to \"build\" (copy) to"),
        ('force', 'f', "forcibly build everything (ignore file timestamps"),
        ('executable=', 'e', "specify final destination interpreter path"),
    ]

    boolean_options = ['force']

    def initialize_options(self):
        self.build_dir = None
        self.scripts = None
        self.force = None
        self.executable = None

    def finalize_options(self):
        self.set_undefined_options(
            'build',
            ('build_scripts', 'build_dir'),
            ('force', 'force'),
            ('executable', 'executable'),
        )
        self.scripts = self.distribution.scripts

    def get_source_files(self):
        return self.scripts

    def run(self):
        if not self.scripts:
            return
        self.copy_scripts()

    def copy_scripts(self):
        """
        Copy each script listed in ``self.scripts``.

        If a script is marked as a Python script (first line matches
        'shebang_pattern', i.e. starts with ``#!`` and contains
        "python"), then adjust in the copy the first line to refer to
        the current Python interpreter.
        """
        self.mkpath(self.build_dir)
        outfiles = []
        updated_files = []
        for script in self.scripts:
            self._copy_script(script, outfiles, updated_files)

        self._change_modes(outfiles)

        return outfiles, updated_files

    def _copy_script(self, script, outfiles, updated_files):  # noqa: C901
        shebang_match = None
        script = convert_path(script)
        outfile = os.path.join(self.build_dir, os.path.basename(script))
        outfiles.append(outfile)

        if not self.force and not newer(script, outfile):
            log.debug("not copying %s (up-to-date)", script)
            return

        # Always open the file, but ignore failures in dry-run mode
        # in order to attempt to copy directly.
        try:
            f = tokenize.open(script)
        except OSError:
            if not self.dry_run:
                raise
            f = None
        else:
            first_line = f.readline()
            if not first_line:
                self.warn("%s is an empty file (skipping)" % script)
                return

            shebang_match = shebang_pattern.match(first_line)

        updated_files.append(outfile)
        if shebang_match:
            log.info("copying and adjusting %s -> %s", script, self.build_dir)
            if not self.dry_run:
                if not sysconfig.python_build:
                    executable = self.executable
                else:
                    executable = os.path.join(
                        sysconfig.get_config_var("BINDIR"),
                        "python%s%s"
                        % (
                            sysconfig.get_config_var("VERSION"),
                            sysconfig.get_config_var("EXE"),
                        ),
                    )
                post_interp = shebang_match.group(1) or ''
                shebang = "#!" + executable + post_interp + "\n"
                self._validate_shebang(shebang, f.encoding)
                with open(outfile, "w", encoding=f.encoding) as outf:
                    outf.write(shebang)
                    outf.writelines(f.readlines())
            if f:
                f.close()
        else:
            if f:
                f.close()
            self.copy_file(script, outfile)

    def _change_modes(self, outfiles):
        if os.name != 'posix':
            return

        for file in outfiles:
            self._change_mode(file)

    def _change_mode(self, file):
        if self.dry_run:
            log.info("changing mode of %s", file)
            return

        oldmode = os.stat(file)[ST_MODE] & 0o7777
        newmode = (oldmode | 0o555) & 0o7777
        if newmode != oldmode:
            log.info("changing mode of %s from %o to %o", file, oldmode, newmode)
            os.chmod(file, newmode)

    @staticmethod
    def _validate_shebang(shebang, encoding):
        # Python parser starts to read a script using UTF-8 until
        # it gets a #coding:xxx cookie. The shebang has to be the
        # first line of a file, the #coding:xxx cookie cannot be
        # written before. So the shebang has to be encodable to
        # UTF-8.
        try:
            shebang.encode('utf-8')
        except UnicodeEncodeError:
            raise ValueError(
                "The shebang ({!r}) is not encodable " "to utf-8".format(shebang)
            )

        # If the script is encoded to a custom encoding (use a
        # #coding:xxx cookie), the shebang has to be encodable to
        # the script encoding too.
        try:
            shebang.encode(encoding)
        except UnicodeEncodeError:
            raise ValueError(
                "The shebang ({!r}) is not encodable "
                "to the script encoding ({})".format(shebang, encoding)
            )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/check.py0000644000175100001730000001141014467657412023120 0ustar00runnerdocker"""distutils.command.check

Implements the Distutils 'check' command.
"""
import contextlib

from ..core import Command
from ..errors import DistutilsSetupError

with contextlib.suppress(ImportError):
    import docutils.utils
    import docutils.parsers.rst
    import docutils.frontend
    import docutils.nodes

    class SilentReporter(docutils.utils.Reporter):
        def __init__(
            self,
            source,
            report_level,
            halt_level,
            stream=None,
            debug=0,
            encoding='ascii',
            error_handler='replace',
        ):
            self.messages = []
            super().__init__(
                source, report_level, halt_level, stream, debug, encoding, error_handler
            )

        def system_message(self, level, message, *children, **kwargs):
            self.messages.append((level, message, children, kwargs))
            return docutils.nodes.system_message(
                message, level=level, type=self.levels[level], *children, **kwargs
            )


class check(Command):
    """This command checks the meta-data of the package."""

    description = "perform some checks on the package"
    user_options = [
        ('metadata', 'm', 'Verify meta-data'),
        (
            'restructuredtext',
            'r',
            (
                'Checks if long string meta-data syntax '
                'are reStructuredText-compliant'
            ),
        ),
        ('strict', 's', 'Will exit with an error if a check fails'),
    ]

    boolean_options = ['metadata', 'restructuredtext', 'strict']

    def initialize_options(self):
        """Sets default values for options."""
        self.restructuredtext = 0
        self.metadata = 1
        self.strict = 0
        self._warnings = 0

    def finalize_options(self):
        pass

    def warn(self, msg):
        """Counts the number of warnings that occurs."""
        self._warnings += 1
        return Command.warn(self, msg)

    def run(self):
        """Runs the command."""
        # perform the various tests
        if self.metadata:
            self.check_metadata()
        if self.restructuredtext:
            if 'docutils' in globals():
                try:
                    self.check_restructuredtext()
                except TypeError as exc:
                    raise DistutilsSetupError(str(exc))
            elif self.strict:
                raise DistutilsSetupError('The docutils package is needed.')

        # let's raise an error in strict mode, if we have at least
        # one warning
        if self.strict and self._warnings > 0:
            raise DistutilsSetupError('Please correct your package.')

    def check_metadata(self):
        """Ensures that all required elements of meta-data are supplied.

        Required fields:
            name, version

        Warns if any are missing.
        """
        metadata = self.distribution.metadata

        missing = []
        for attr in 'name', 'version':
            if not getattr(metadata, attr, None):
                missing.append(attr)

        if missing:
            self.warn("missing required meta-data: %s" % ', '.join(missing))

    def check_restructuredtext(self):
        """Checks if the long string fields are reST-compliant."""
        data = self.distribution.get_long_description()
        for warning in self._check_rst_data(data):
            line = warning[-1].get('line')
            if line is None:
                warning = warning[1]
            else:
                warning = '{} (line {})'.format(warning[1], line)
            self.warn(warning)

    def _check_rst_data(self, data):
        """Returns warnings when the provided data doesn't compile."""
        # the include and csv_table directives need this to be a path
        source_path = self.distribution.script_name or 'setup.py'
        parser = docutils.parsers.rst.Parser()
        settings = docutils.frontend.OptionParser(
            components=(docutils.parsers.rst.Parser,)
        ).get_default_values()
        settings.tab_width = 4
        settings.pep_references = None
        settings.rfc_references = None
        reporter = SilentReporter(
            source_path,
            settings.report_level,
            settings.halt_level,
            stream=settings.warning_stream,
            debug=settings.debug,
            encoding=settings.error_encoding,
            error_handler=settings.error_encoding_error_handler,
        )

        document = docutils.nodes.document(settings, reporter, source=source_path)
        document.note_source(source_path, -1)
        try:
            parser.parse(data, document)
        except AttributeError as e:
            reporter.messages.append(
                (-1, 'Could not finish the parsing: %s.' % e, '', {})
            )

        return reporter.messages
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/clean.py0000644000175100001730000000504214467657412023131 0ustar00runnerdocker"""distutils.command.clean

Implements the Distutils 'clean' command."""

# contributed by Bastian Kleineidam , added 2000-03-18

import os
from ..core import Command
from ..dir_util import remove_tree
from distutils._log import log


class clean(Command):
    description = "clean up temporary files from 'build' command"
    user_options = [
        ('build-base=', 'b', "base build directory (default: 'build.build-base')"),
        (
            'build-lib=',
            None,
            "build directory for all modules (default: 'build.build-lib')",
        ),
        ('build-temp=', 't', "temporary build directory (default: 'build.build-temp')"),
        (
            'build-scripts=',
            None,
            "build directory for scripts (default: 'build.build-scripts')",
        ),
        ('bdist-base=', None, "temporary directory for built distributions"),
        ('all', 'a', "remove all build output, not just temporary by-products"),
    ]

    boolean_options = ['all']

    def initialize_options(self):
        self.build_base = None
        self.build_lib = None
        self.build_temp = None
        self.build_scripts = None
        self.bdist_base = None
        self.all = None

    def finalize_options(self):
        self.set_undefined_options(
            'build',
            ('build_base', 'build_base'),
            ('build_lib', 'build_lib'),
            ('build_scripts', 'build_scripts'),
            ('build_temp', 'build_temp'),
        )
        self.set_undefined_options('bdist', ('bdist_base', 'bdist_base'))

    def run(self):
        # remove the build/temp. directory (unless it's already
        # gone)
        if os.path.exists(self.build_temp):
            remove_tree(self.build_temp, dry_run=self.dry_run)
        else:
            log.debug("'%s' does not exist -- can't clean it", self.build_temp)

        if self.all:
            # remove build directories
            for directory in (self.build_lib, self.bdist_base, self.build_scripts):
                if os.path.exists(directory):
                    remove_tree(directory, dry_run=self.dry_run)
                else:
                    log.warning("'%s' does not exist -- can't clean it", directory)

        # just for the heck of it, try to remove the base build directory:
        # we might have emptied it right now, but if not we don't care
        if not self.dry_run:
            try:
                os.rmdir(self.build_base)
                log.info("removing '%s'", self.build_base)
            except OSError:
                pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/config.py0000644000175100001730000003142514467657412023320 0ustar00runnerdocker"""distutils.command.config

Implements the Distutils 'config' command, a (mostly) empty command class
that exists mainly to be sub-classed by specific module distributions and
applications.  The idea is that while every "config" command is different,
at least they're all named the same, and users always see "config" in the
list of standard commands.  Also, this is a good place to put common
configure-like tasks: "try to compile this C code", or "figure out where
this header file lives".
"""

import os
import re

from ..core import Command
from ..errors import DistutilsExecError
from ..sysconfig import customize_compiler
from distutils._log import log

LANG_EXT = {"c": ".c", "c++": ".cxx"}


class config(Command):
    description = "prepare to build"

    user_options = [
        ('compiler=', None, "specify the compiler type"),
        ('cc=', None, "specify the compiler executable"),
        ('include-dirs=', 'I', "list of directories to search for header files"),
        ('define=', 'D', "C preprocessor macros to define"),
        ('undef=', 'U', "C preprocessor macros to undefine"),
        ('libraries=', 'l', "external C libraries to link with"),
        ('library-dirs=', 'L', "directories to search for external C libraries"),
        ('noisy', None, "show every action (compile, link, run, ...) taken"),
        (
            'dump-source',
            None,
            "dump generated source files before attempting to compile them",
        ),
    ]

    # The three standard command methods: since the "config" command
    # does nothing by default, these are empty.

    def initialize_options(self):
        self.compiler = None
        self.cc = None
        self.include_dirs = None
        self.libraries = None
        self.library_dirs = None

        # maximal output for now
        self.noisy = 1
        self.dump_source = 1

        # list of temporary files generated along-the-way that we have
        # to clean at some point
        self.temp_files = []

    def finalize_options(self):
        if self.include_dirs is None:
            self.include_dirs = self.distribution.include_dirs or []
        elif isinstance(self.include_dirs, str):
            self.include_dirs = self.include_dirs.split(os.pathsep)

        if self.libraries is None:
            self.libraries = []
        elif isinstance(self.libraries, str):
            self.libraries = [self.libraries]

        if self.library_dirs is None:
            self.library_dirs = []
        elif isinstance(self.library_dirs, str):
            self.library_dirs = self.library_dirs.split(os.pathsep)

    def run(self):
        pass

    # Utility methods for actual "config" commands.  The interfaces are
    # loosely based on Autoconf macros of similar names.  Sub-classes
    # may use these freely.

    def _check_compiler(self):
        """Check that 'self.compiler' really is a CCompiler object;
        if not, make it one.
        """
        # We do this late, and only on-demand, because this is an expensive
        # import.
        from ..ccompiler import CCompiler, new_compiler

        if not isinstance(self.compiler, CCompiler):
            self.compiler = new_compiler(
                compiler=self.compiler, dry_run=self.dry_run, force=1
            )
            customize_compiler(self.compiler)
            if self.include_dirs:
                self.compiler.set_include_dirs(self.include_dirs)
            if self.libraries:
                self.compiler.set_libraries(self.libraries)
            if self.library_dirs:
                self.compiler.set_library_dirs(self.library_dirs)

    def _gen_temp_sourcefile(self, body, headers, lang):
        filename = "_configtest" + LANG_EXT[lang]
        with open(filename, "w") as file:
            if headers:
                for header in headers:
                    file.write("#include <%s>\n" % header)
                file.write("\n")
            file.write(body)
            if body[-1] != "\n":
                file.write("\n")
        return filename

    def _preprocess(self, body, headers, include_dirs, lang):
        src = self._gen_temp_sourcefile(body, headers, lang)
        out = "_configtest.i"
        self.temp_files.extend([src, out])
        self.compiler.preprocess(src, out, include_dirs=include_dirs)
        return (src, out)

    def _compile(self, body, headers, include_dirs, lang):
        src = self._gen_temp_sourcefile(body, headers, lang)
        if self.dump_source:
            dump_file(src, "compiling '%s':" % src)
        (obj,) = self.compiler.object_filenames([src])
        self.temp_files.extend([src, obj])
        self.compiler.compile([src], include_dirs=include_dirs)
        return (src, obj)

    def _link(self, body, headers, include_dirs, libraries, library_dirs, lang):
        (src, obj) = self._compile(body, headers, include_dirs, lang)
        prog = os.path.splitext(os.path.basename(src))[0]
        self.compiler.link_executable(
            [obj],
            prog,
            libraries=libraries,
            library_dirs=library_dirs,
            target_lang=lang,
        )

        if self.compiler.exe_extension is not None:
            prog = prog + self.compiler.exe_extension
        self.temp_files.append(prog)

        return (src, obj, prog)

    def _clean(self, *filenames):
        if not filenames:
            filenames = self.temp_files
            self.temp_files = []
        log.info("removing: %s", ' '.join(filenames))
        for filename in filenames:
            try:
                os.remove(filename)
            except OSError:
                pass

    # XXX these ignore the dry-run flag: what to do, what to do? even if
    # you want a dry-run build, you still need some sort of configuration
    # info.  My inclination is to make it up to the real config command to
    # consult 'dry_run', and assume a default (minimal) configuration if
    # true.  The problem with trying to do it here is that you'd have to
    # return either true or false from all the 'try' methods, neither of
    # which is correct.

    # XXX need access to the header search path and maybe default macros.

    def try_cpp(self, body=None, headers=None, include_dirs=None, lang="c"):
        """Construct a source file from 'body' (a string containing lines
        of C/C++ code) and 'headers' (a list of header files to include)
        and run it through the preprocessor.  Return true if the
        preprocessor succeeded, false if there were any errors.
        ('body' probably isn't of much use, but what the heck.)
        """
        from ..ccompiler import CompileError

        self._check_compiler()
        ok = True
        try:
            self._preprocess(body, headers, include_dirs, lang)
        except CompileError:
            ok = False

        self._clean()
        return ok

    def search_cpp(self, pattern, body=None, headers=None, include_dirs=None, lang="c"):
        """Construct a source file (just like 'try_cpp()'), run it through
        the preprocessor, and return true if any line of the output matches
        'pattern'.  'pattern' should either be a compiled regex object or a
        string containing a regex.  If both 'body' and 'headers' are None,
        preprocesses an empty file -- which can be useful to determine the
        symbols the preprocessor and compiler set by default.
        """
        self._check_compiler()
        src, out = self._preprocess(body, headers, include_dirs, lang)

        if isinstance(pattern, str):
            pattern = re.compile(pattern)

        with open(out) as file:
            match = False
            while True:
                line = file.readline()
                if line == '':
                    break
                if pattern.search(line):
                    match = True
                    break

        self._clean()
        return match

    def try_compile(self, body, headers=None, include_dirs=None, lang="c"):
        """Try to compile a source file built from 'body' and 'headers'.
        Return true on success, false otherwise.
        """
        from ..ccompiler import CompileError

        self._check_compiler()
        try:
            self._compile(body, headers, include_dirs, lang)
            ok = True
        except CompileError:
            ok = False

        log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

    def try_link(
        self,
        body,
        headers=None,
        include_dirs=None,
        libraries=None,
        library_dirs=None,
        lang="c",
    ):
        """Try to compile and link a source file, built from 'body' and
        'headers', to executable form.  Return true on success, false
        otherwise.
        """
        from ..ccompiler import CompileError, LinkError

        self._check_compiler()
        try:
            self._link(body, headers, include_dirs, libraries, library_dirs, lang)
            ok = True
        except (CompileError, LinkError):
            ok = False

        log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

    def try_run(
        self,
        body,
        headers=None,
        include_dirs=None,
        libraries=None,
        library_dirs=None,
        lang="c",
    ):
        """Try to compile, link to an executable, and run a program
        built from 'body' and 'headers'.  Return true on success, false
        otherwise.
        """
        from ..ccompiler import CompileError, LinkError

        self._check_compiler()
        try:
            src, obj, exe = self._link(
                body, headers, include_dirs, libraries, library_dirs, lang
            )
            self.spawn([exe])
            ok = True
        except (CompileError, LinkError, DistutilsExecError):
            ok = False

        log.info(ok and "success!" or "failure.")
        self._clean()
        return ok

    # -- High-level methods --------------------------------------------
    # (these are the ones that are actually likely to be useful
    # when implementing a real-world config command!)

    def check_func(
        self,
        func,
        headers=None,
        include_dirs=None,
        libraries=None,
        library_dirs=None,
        decl=0,
        call=0,
    ):
        """Determine if function 'func' is available by constructing a
        source file that refers to 'func', and compiles and links it.
        If everything succeeds, returns true; otherwise returns false.

        The constructed source file starts out by including the header
        files listed in 'headers'.  If 'decl' is true, it then declares
        'func' (as "int func()"); you probably shouldn't supply 'headers'
        and set 'decl' true in the same call, or you might get errors about
        a conflicting declarations for 'func'.  Finally, the constructed
        'main()' function either references 'func' or (if 'call' is true)
        calls it.  'libraries' and 'library_dirs' are used when
        linking.
        """
        self._check_compiler()
        body = []
        if decl:
            body.append("int %s ();" % func)
        body.append("int main () {")
        if call:
            body.append("  %s();" % func)
        else:
            body.append("  %s;" % func)
        body.append("}")
        body = "\n".join(body) + "\n"

        return self.try_link(body, headers, include_dirs, libraries, library_dirs)

    def check_lib(
        self,
        library,
        library_dirs=None,
        headers=None,
        include_dirs=None,
        other_libraries=[],
    ):
        """Determine if 'library' is available to be linked against,
        without actually checking that any particular symbols are provided
        by it.  'headers' will be used in constructing the source file to
        be compiled, but the only effect of this is to check if all the
        header files listed are available.  Any libraries listed in
        'other_libraries' will be included in the link, in case 'library'
        has symbols that depend on other libraries.
        """
        self._check_compiler()
        return self.try_link(
            "int main (void) { }",
            headers,
            include_dirs,
            [library] + other_libraries,
            library_dirs,
        )

    def check_header(self, header, include_dirs=None, library_dirs=None, lang="c"):
        """Determine if the system header file named by 'header_file'
        exists and can be found by the preprocessor; return true if so,
        false otherwise.
        """
        return self.try_cpp(
            body="/* No body */", headers=[header], include_dirs=include_dirs
        )


def dump_file(filename, head=None):
    """Dumps a file content into log.info.

    If head is not None, will be dumped before the file content.
    """
    if head is None:
        log.info('%s', filename)
    else:
        log.info(head)
    file = open(filename)
    try:
        log.info(file.read())
    finally:
        file.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/install.py0000644000175100001730000007271114467657412023524 0ustar00runnerdocker"""distutils.command.install

Implements the Distutils 'install' command."""

import sys
import os
import contextlib
import sysconfig
import itertools

from distutils._log import log
from ..core import Command
from ..debug import DEBUG
from ..sysconfig import get_config_vars
from ..file_util import write_file
from ..util import convert_path, subst_vars, change_root
from ..util import get_platform
from ..errors import DistutilsOptionError, DistutilsPlatformError
from . import _framework_compat as fw
from .. import _collections

from site import USER_BASE
from site import USER_SITE

HAS_USER_SITE = True

WINDOWS_SCHEME = {
    'purelib': '{base}/Lib/site-packages',
    'platlib': '{base}/Lib/site-packages',
    'headers': '{base}/Include/{dist_name}',
    'scripts': '{base}/Scripts',
    'data': '{base}',
}

INSTALL_SCHEMES = {
    'posix_prefix': {
        'purelib': '{base}/lib/{implementation_lower}{py_version_short}/site-packages',
        'platlib': '{platbase}/{platlibdir}/{implementation_lower}'
        '{py_version_short}/site-packages',
        'headers': '{base}/include/{implementation_lower}'
        '{py_version_short}{abiflags}/{dist_name}',
        'scripts': '{base}/bin',
        'data': '{base}',
    },
    'posix_home': {
        'purelib': '{base}/lib/{implementation_lower}',
        'platlib': '{base}/{platlibdir}/{implementation_lower}',
        'headers': '{base}/include/{implementation_lower}/{dist_name}',
        'scripts': '{base}/bin',
        'data': '{base}',
    },
    'nt': WINDOWS_SCHEME,
    'pypy': {
        'purelib': '{base}/site-packages',
        'platlib': '{base}/site-packages',
        'headers': '{base}/include/{dist_name}',
        'scripts': '{base}/bin',
        'data': '{base}',
    },
    'pypy_nt': {
        'purelib': '{base}/site-packages',
        'platlib': '{base}/site-packages',
        'headers': '{base}/include/{dist_name}',
        'scripts': '{base}/Scripts',
        'data': '{base}',
    },
}

# user site schemes
if HAS_USER_SITE:
    INSTALL_SCHEMES['nt_user'] = {
        'purelib': '{usersite}',
        'platlib': '{usersite}',
        'headers': '{userbase}/{implementation}{py_version_nodot_plat}'
        '/Include/{dist_name}',
        'scripts': '{userbase}/{implementation}{py_version_nodot_plat}/Scripts',
        'data': '{userbase}',
    }

    INSTALL_SCHEMES['posix_user'] = {
        'purelib': '{usersite}',
        'platlib': '{usersite}',
        'headers': '{userbase}/include/{implementation_lower}'
        '{py_version_short}{abiflags}/{dist_name}',
        'scripts': '{userbase}/bin',
        'data': '{userbase}',
    }


INSTALL_SCHEMES.update(fw.schemes)


# The keys to an installation scheme; if any new types of files are to be
# installed, be sure to add an entry to every installation scheme above,
# and to SCHEME_KEYS here.
SCHEME_KEYS = ('purelib', 'platlib', 'headers', 'scripts', 'data')


def _load_sysconfig_schemes():
    with contextlib.suppress(AttributeError):
        return {
            scheme: sysconfig.get_paths(scheme, expand=False)
            for scheme in sysconfig.get_scheme_names()
        }


def _load_schemes():
    """
    Extend default schemes with schemes from sysconfig.
    """

    sysconfig_schemes = _load_sysconfig_schemes() or {}

    return {
        scheme: {
            **INSTALL_SCHEMES.get(scheme, {}),
            **sysconfig_schemes.get(scheme, {}),
        }
        for scheme in set(itertools.chain(INSTALL_SCHEMES, sysconfig_schemes))
    }


def _get_implementation():
    if hasattr(sys, 'pypy_version_info'):
        return 'PyPy'
    else:
        return 'Python'


def _select_scheme(ob, name):
    scheme = _inject_headers(name, _load_scheme(_resolve_scheme(name)))
    vars(ob).update(_remove_set(ob, _scheme_attrs(scheme)))


def _remove_set(ob, attrs):
    """
    Include only attrs that are None in ob.
    """
    return {key: value for key, value in attrs.items() if getattr(ob, key) is None}


def _resolve_scheme(name):
    os_name, sep, key = name.partition('_')
    try:
        resolved = sysconfig.get_preferred_scheme(key)
    except Exception:
        resolved = fw.scheme(_pypy_hack(name))
    return resolved


def _load_scheme(name):
    return _load_schemes()[name]


def _inject_headers(name, scheme):
    """
    Given a scheme name and the resolved scheme,
    if the scheme does not include headers, resolve
    the fallback scheme for the name and use headers
    from it. pypa/distutils#88
    """
    # Bypass the preferred scheme, which may not
    # have defined headers.
    fallback = _load_scheme(_pypy_hack(name))
    scheme.setdefault('headers', fallback['headers'])
    return scheme


def _scheme_attrs(scheme):
    """Resolve install directories by applying the install schemes."""
    return {f'install_{key}': scheme[key] for key in SCHEME_KEYS}


def _pypy_hack(name):
    PY37 = sys.version_info < (3, 8)
    old_pypy = hasattr(sys, 'pypy_version_info') and PY37
    prefix = not name.endswith(('_user', '_home'))
    pypy_name = 'pypy' + '_nt' * (os.name == 'nt')
    return pypy_name if old_pypy and prefix else name


class install(Command):
    description = "install everything from build directory"

    user_options = [
        # Select installation scheme and set base director(y|ies)
        ('prefix=', None, "installation prefix"),
        ('exec-prefix=', None, "(Unix only) prefix for platform-specific files"),
        ('home=', None, "(Unix only) home directory to install under"),
        # Or, just set the base director(y|ies)
        (
            'install-base=',
            None,
            "base installation directory (instead of --prefix or --home)",
        ),
        (
            'install-platbase=',
            None,
            "base installation directory for platform-specific files "
            + "(instead of --exec-prefix or --home)",
        ),
        ('root=', None, "install everything relative to this alternate root directory"),
        # Or, explicitly set the installation scheme
        (
            'install-purelib=',
            None,
            "installation directory for pure Python module distributions",
        ),
        (
            'install-platlib=',
            None,
            "installation directory for non-pure module distributions",
        ),
        (
            'install-lib=',
            None,
            "installation directory for all module distributions "
            + "(overrides --install-purelib and --install-platlib)",
        ),
        ('install-headers=', None, "installation directory for C/C++ headers"),
        ('install-scripts=', None, "installation directory for Python scripts"),
        ('install-data=', None, "installation directory for data files"),
        # Byte-compilation options -- see install_lib.py for details, as
        # these are duplicated from there (but only install_lib does
        # anything with them).
        ('compile', 'c', "compile .py to .pyc [default]"),
        ('no-compile', None, "don't compile .py files"),
        (
            'optimize=',
            'O',
            "also compile with optimization: -O1 for \"python -O\", "
            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
        ),
        # Miscellaneous control options
        ('force', 'f', "force installation (overwrite any existing files)"),
        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
        # Where to install documentation (eventually!)
        # ('doc-format=', None, "format of documentation to generate"),
        # ('install-man=', None, "directory for Unix man pages"),
        # ('install-html=', None, "directory for HTML documentation"),
        # ('install-info=', None, "directory for GNU info files"),
        ('record=', None, "filename in which to record list of installed files"),
    ]

    boolean_options = ['compile', 'force', 'skip-build']

    if HAS_USER_SITE:
        user_options.append(
            ('user', None, "install in user site-package '%s'" % USER_SITE)
        )
        boolean_options.append('user')

    negative_opt = {'no-compile': 'compile'}

    def initialize_options(self):
        """Initializes options."""
        # High-level options: these select both an installation base
        # and scheme.
        self.prefix = None
        self.exec_prefix = None
        self.home = None
        self.user = 0

        # These select only the installation base; it's up to the user to
        # specify the installation scheme (currently, that means supplying
        # the --install-{platlib,purelib,scripts,data} options).
        self.install_base = None
        self.install_platbase = None
        self.root = None

        # These options are the actual installation directories; if not
        # supplied by the user, they are filled in using the installation
        # scheme implied by prefix/exec-prefix/home and the contents of
        # that installation scheme.
        self.install_purelib = None  # for pure module distributions
        self.install_platlib = None  # non-pure (dists w/ extensions)
        self.install_headers = None  # for C/C++ headers
        self.install_lib = None  # set to either purelib or platlib
        self.install_scripts = None
        self.install_data = None
        self.install_userbase = USER_BASE
        self.install_usersite = USER_SITE

        self.compile = None
        self.optimize = None

        # Deprecated
        # These two are for putting non-packagized distributions into their
        # own directory and creating a .pth file if it makes sense.
        # 'extra_path' comes from the setup file; 'install_path_file' can
        # be turned off if it makes no sense to install a .pth file.  (But
        # better to install it uselessly than to guess wrong and not
        # install it when it's necessary and would be used!)  Currently,
        # 'install_path_file' is always true unless some outsider meddles
        # with it.
        self.extra_path = None
        self.install_path_file = 1

        # 'force' forces installation, even if target files are not
        # out-of-date.  'skip_build' skips running the "build" command,
        # handy if you know it's not necessary.  'warn_dir' (which is *not*
        # a user option, it's just there so the bdist_* commands can turn
        # it off) determines whether we warn about installing to a
        # directory not in sys.path.
        self.force = 0
        self.skip_build = 0
        self.warn_dir = 1

        # These are only here as a conduit from the 'build' command to the
        # 'install_*' commands that do the real work.  ('build_base' isn't
        # actually used anywhere, but it might be useful in future.)  They
        # are not user options, because if the user told the install
        # command where the build directory is, that wouldn't affect the
        # build command.
        self.build_base = None
        self.build_lib = None

        # Not defined yet because we don't know anything about
        # documentation yet.
        # self.install_man = None
        # self.install_html = None
        # self.install_info = None

        self.record = None

    # -- Option finalizing methods -------------------------------------
    # (This is rather more involved than for most commands,
    # because this is where the policy for installing third-
    # party Python modules on various platforms given a wide
    # array of user input is decided.  Yes, it's quite complex!)

    def finalize_options(self):  # noqa: C901
        """Finalizes options."""
        # This method (and its helpers, like 'finalize_unix()',
        # 'finalize_other()', and 'select_scheme()') is where the default
        # installation directories for modules, extension modules, and
        # anything else we care to install from a Python module
        # distribution.  Thus, this code makes a pretty important policy
        # statement about how third-party stuff is added to a Python
        # installation!  Note that the actual work of installation is done
        # by the relatively simple 'install_*' commands; they just take
        # their orders from the installation directory options determined
        # here.

        # Check for errors/inconsistencies in the options; first, stuff
        # that's wrong on any platform.

        if (self.prefix or self.exec_prefix or self.home) and (
            self.install_base or self.install_platbase
        ):
            raise DistutilsOptionError(
                "must supply either prefix/exec-prefix/home or "
                + "install-base/install-platbase -- not both"
            )

        if self.home and (self.prefix or self.exec_prefix):
            raise DistutilsOptionError(
                "must supply either home or prefix/exec-prefix -- not both"
            )

        if self.user and (
            self.prefix
            or self.exec_prefix
            or self.home
            or self.install_base
            or self.install_platbase
        ):
            raise DistutilsOptionError(
                "can't combine user with prefix, "
                "exec_prefix/home, or install_(plat)base"
            )

        # Next, stuff that's wrong (or dubious) only on certain platforms.
        if os.name != "posix":
            if self.exec_prefix:
                self.warn("exec-prefix option ignored on this platform")
                self.exec_prefix = None

        # Now the interesting logic -- so interesting that we farm it out
        # to other methods.  The goal of these methods is to set the final
        # values for the install_{lib,scripts,data,...}  options, using as
        # input a heady brew of prefix, exec_prefix, home, install_base,
        # install_platbase, user-supplied versions of
        # install_{purelib,platlib,lib,scripts,data,...}, and the
        # install schemes.  Phew!

        self.dump_dirs("pre-finalize_{unix,other}")

        if os.name == 'posix':
            self.finalize_unix()
        else:
            self.finalize_other()

        self.dump_dirs("post-finalize_{unix,other}()")

        # Expand configuration variables, tilde, etc. in self.install_base
        # and self.install_platbase -- that way, we can use $base or
        # $platbase in the other installation directories and not worry
        # about needing recursive variable expansion (shudder).

        py_version = sys.version.split()[0]
        (prefix, exec_prefix) = get_config_vars('prefix', 'exec_prefix')
        try:
            abiflags = sys.abiflags
        except AttributeError:
            # sys.abiflags may not be defined on all platforms.
            abiflags = ''
        local_vars = {
            'dist_name': self.distribution.get_name(),
            'dist_version': self.distribution.get_version(),
            'dist_fullname': self.distribution.get_fullname(),
            'py_version': py_version,
            'py_version_short': '%d.%d' % sys.version_info[:2],
            'py_version_nodot': '%d%d' % sys.version_info[:2],
            'sys_prefix': prefix,
            'prefix': prefix,
            'sys_exec_prefix': exec_prefix,
            'exec_prefix': exec_prefix,
            'abiflags': abiflags,
            'platlibdir': getattr(sys, 'platlibdir', 'lib'),
            'implementation_lower': _get_implementation().lower(),
            'implementation': _get_implementation(),
        }

        # vars for compatibility on older Pythons
        compat_vars = dict(
            # Python 3.9 and earlier
            py_version_nodot_plat=getattr(sys, 'winver', '').replace('.', ''),
        )

        if HAS_USER_SITE:
            local_vars['userbase'] = self.install_userbase
            local_vars['usersite'] = self.install_usersite

        self.config_vars = _collections.DictStack(
            [fw.vars(), compat_vars, sysconfig.get_config_vars(), local_vars]
        )

        self.expand_basedirs()

        self.dump_dirs("post-expand_basedirs()")

        # Now define config vars for the base directories so we can expand
        # everything else.
        local_vars['base'] = self.install_base
        local_vars['platbase'] = self.install_platbase

        if DEBUG:
            from pprint import pprint

            print("config vars:")
            pprint(dict(self.config_vars))

        # Expand "~" and configuration variables in the installation
        # directories.
        self.expand_dirs()

        self.dump_dirs("post-expand_dirs()")

        # Create directories in the home dir:
        if self.user:
            self.create_home_path()

        # Pick the actual directory to install all modules to: either
        # install_purelib or install_platlib, depending on whether this
        # module distribution is pure or not.  Of course, if the user
        # already specified install_lib, use their selection.
        if self.install_lib is None:
            if self.distribution.has_ext_modules():  # has extensions: non-pure
                self.install_lib = self.install_platlib
            else:
                self.install_lib = self.install_purelib

        # Convert directories from Unix /-separated syntax to the local
        # convention.
        self.convert_paths(
            'lib',
            'purelib',
            'platlib',
            'scripts',
            'data',
            'headers',
            'userbase',
            'usersite',
        )

        # Deprecated
        # Well, we're not actually fully completely finalized yet: we still
        # have to deal with 'extra_path', which is the hack for allowing
        # non-packagized module distributions (hello, Numerical Python!) to
        # get their own directories.
        self.handle_extra_path()
        self.install_libbase = self.install_lib  # needed for .pth file
        self.install_lib = os.path.join(self.install_lib, self.extra_dirs)

        # If a new root directory was supplied, make all the installation
        # dirs relative to it.
        if self.root is not None:
            self.change_roots(
                'libbase', 'lib', 'purelib', 'platlib', 'scripts', 'data', 'headers'
            )

        self.dump_dirs("after prepending root")

        # Find out the build directories, ie. where to install from.
        self.set_undefined_options(
            'build', ('build_base', 'build_base'), ('build_lib', 'build_lib')
        )

        # Punt on doc directories for now -- after all, we're punting on
        # documentation completely!

    def dump_dirs(self, msg):
        """Dumps the list of user options."""
        if not DEBUG:
            return
        from ..fancy_getopt import longopt_xlate

        log.debug(msg + ":")
        for opt in self.user_options:
            opt_name = opt[0]
            if opt_name[-1] == "=":
                opt_name = opt_name[0:-1]
            if opt_name in self.negative_opt:
                opt_name = self.negative_opt[opt_name]
                opt_name = opt_name.translate(longopt_xlate)
                val = not getattr(self, opt_name)
            else:
                opt_name = opt_name.translate(longopt_xlate)
                val = getattr(self, opt_name)
            log.debug("  %s: %s", opt_name, val)

    def finalize_unix(self):
        """Finalizes options for posix platforms."""
        if self.install_base is not None or self.install_platbase is not None:
            incomplete_scheme = (
                (
                    self.install_lib is None
                    and self.install_purelib is None
                    and self.install_platlib is None
                )
                or self.install_headers is None
                or self.install_scripts is None
                or self.install_data is None
            )
            if incomplete_scheme:
                raise DistutilsOptionError(
                    "install-base or install-platbase supplied, but "
                    "installation scheme is incomplete"
                )
            return

        if self.user:
            if self.install_userbase is None:
                raise DistutilsPlatformError("User base directory is not specified")
            self.install_base = self.install_platbase = self.install_userbase
            self.select_scheme("posix_user")
        elif self.home is not None:
            self.install_base = self.install_platbase = self.home
            self.select_scheme("posix_home")
        else:
            if self.prefix is None:
                if self.exec_prefix is not None:
                    raise DistutilsOptionError(
                        "must not supply exec-prefix without prefix"
                    )

                # Allow Fedora to add components to the prefix
                _prefix_addition = getattr(sysconfig, '_prefix_addition', "")

                self.prefix = os.path.normpath(sys.prefix) + _prefix_addition
                self.exec_prefix = os.path.normpath(sys.exec_prefix) + _prefix_addition

            else:
                if self.exec_prefix is None:
                    self.exec_prefix = self.prefix

            self.install_base = self.prefix
            self.install_platbase = self.exec_prefix
            self.select_scheme("posix_prefix")

    def finalize_other(self):
        """Finalizes options for non-posix platforms"""
        if self.user:
            if self.install_userbase is None:
                raise DistutilsPlatformError("User base directory is not specified")
            self.install_base = self.install_platbase = self.install_userbase
            self.select_scheme(os.name + "_user")
        elif self.home is not None:
            self.install_base = self.install_platbase = self.home
            self.select_scheme("posix_home")
        else:
            if self.prefix is None:
                self.prefix = os.path.normpath(sys.prefix)

            self.install_base = self.install_platbase = self.prefix
            try:
                self.select_scheme(os.name)
            except KeyError:
                raise DistutilsPlatformError(
                    "I don't know how to install stuff on '%s'" % os.name
                )

    def select_scheme(self, name):
        _select_scheme(self, name)

    def _expand_attrs(self, attrs):
        for attr in attrs:
            val = getattr(self, attr)
            if val is not None:
                if os.name in ('posix', 'nt'):
                    val = os.path.expanduser(val)
                val = subst_vars(val, self.config_vars)
                setattr(self, attr, val)

    def expand_basedirs(self):
        """Calls `os.path.expanduser` on install_base, install_platbase and
        root."""
        self._expand_attrs(['install_base', 'install_platbase', 'root'])

    def expand_dirs(self):
        """Calls `os.path.expanduser` on install dirs."""
        self._expand_attrs(
            [
                'install_purelib',
                'install_platlib',
                'install_lib',
                'install_headers',
                'install_scripts',
                'install_data',
            ]
        )

    def convert_paths(self, *names):
        """Call `convert_path` over `names`."""
        for name in names:
            attr = "install_" + name
            setattr(self, attr, convert_path(getattr(self, attr)))

    def handle_extra_path(self):
        """Set `path_file` and `extra_dirs` using `extra_path`."""
        if self.extra_path is None:
            self.extra_path = self.distribution.extra_path

        if self.extra_path is not None:
            log.warning(
                "Distribution option extra_path is deprecated. "
                "See issue27919 for details."
            )
            if isinstance(self.extra_path, str):
                self.extra_path = self.extra_path.split(',')

            if len(self.extra_path) == 1:
                path_file = extra_dirs = self.extra_path[0]
            elif len(self.extra_path) == 2:
                path_file, extra_dirs = self.extra_path
            else:
                raise DistutilsOptionError(
                    "'extra_path' option must be a list, tuple, or "
                    "comma-separated string with 1 or 2 elements"
                )

            # convert to local form in case Unix notation used (as it
            # should be in setup scripts)
            extra_dirs = convert_path(extra_dirs)
        else:
            path_file = None
            extra_dirs = ''

        # XXX should we warn if path_file and not extra_dirs? (in which
        # case the path file would be harmless but pointless)
        self.path_file = path_file
        self.extra_dirs = extra_dirs

    def change_roots(self, *names):
        """Change the install directories pointed by name using root."""
        for name in names:
            attr = "install_" + name
            setattr(self, attr, change_root(self.root, getattr(self, attr)))

    def create_home_path(self):
        """Create directories under ~."""
        if not self.user:
            return
        home = convert_path(os.path.expanduser("~"))
        for name, path in self.config_vars.items():
            if str(path).startswith(home) and not os.path.isdir(path):
                self.debug_print("os.makedirs('%s', 0o700)" % path)
                os.makedirs(path, 0o700)

    # -- Command execution methods -------------------------------------

    def run(self):
        """Runs the command."""
        # Obviously have to build before we can install
        if not self.skip_build:
            self.run_command('build')
            # If we built for any other platform, we can't install.
            build_plat = self.distribution.get_command_obj('build').plat_name
            # check warn_dir - it is a clue that the 'install' is happening
            # internally, and not to sys.path, so we don't check the platform
            # matches what we are running.
            if self.warn_dir and build_plat != get_platform():
                raise DistutilsPlatformError("Can't install when " "cross-compiling")

        # Run all sub-commands (at least those that need to be run)
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        if self.path_file:
            self.create_path_file()

        # write list of installed files, if requested.
        if self.record:
            outputs = self.get_outputs()
            if self.root:  # strip any package prefix
                root_len = len(self.root)
                for counter in range(len(outputs)):
                    outputs[counter] = outputs[counter][root_len:]
            self.execute(
                write_file,
                (self.record, outputs),
                "writing list of installed files to '%s'" % self.record,
            )

        sys_path = map(os.path.normpath, sys.path)
        sys_path = map(os.path.normcase, sys_path)
        install_lib = os.path.normcase(os.path.normpath(self.install_lib))
        if (
            self.warn_dir
            and not (self.path_file and self.install_path_file)
            and install_lib not in sys_path
        ):
            log.debug(
                (
                    "modules installed to '%s', which is not in "
                    "Python's module search path (sys.path) -- "
                    "you'll have to change the search path yourself"
                ),
                self.install_lib,
            )

    def create_path_file(self):
        """Creates the .pth file"""
        filename = os.path.join(self.install_libbase, self.path_file + ".pth")
        if self.install_path_file:
            self.execute(
                write_file, (filename, [self.extra_dirs]), "creating %s" % filename
            )
        else:
            self.warn("path file '%s' not created" % filename)

    # -- Reporting methods ---------------------------------------------

    def get_outputs(self):
        """Assembles the outputs of all the sub-commands."""
        outputs = []
        for cmd_name in self.get_sub_commands():
            cmd = self.get_finalized_command(cmd_name)
            # Add the contents of cmd.get_outputs(), ensuring
            # that outputs doesn't contain duplicate entries
            for filename in cmd.get_outputs():
                if filename not in outputs:
                    outputs.append(filename)

        if self.path_file and self.install_path_file:
            outputs.append(os.path.join(self.install_libbase, self.path_file + ".pth"))

        return outputs

    def get_inputs(self):
        """Returns the inputs of all the sub-commands"""
        # XXX gee, this looks familiar ;-(
        inputs = []
        for cmd_name in self.get_sub_commands():
            cmd = self.get_finalized_command(cmd_name)
            inputs.extend(cmd.get_inputs())

        return inputs

    # -- Predicates for sub-command list -------------------------------

    def has_lib(self):
        """Returns true if the current distribution has any Python
        modules to install."""
        return (
            self.distribution.has_pure_modules() or self.distribution.has_ext_modules()
        )

    def has_headers(self):
        """Returns true if the current distribution has any headers to
        install."""
        return self.distribution.has_headers()

    def has_scripts(self):
        """Returns true if the current distribution has any scripts to.
        install."""
        return self.distribution.has_scripts()

    def has_data(self):
        """Returns true if the current distribution has any data to.
        install."""
        return self.distribution.has_data_files()

    # 'sub_commands': a list of commands this command might have to run to
    # get its work done.  See cmd.py for more info.
    sub_commands = [
        ('install_lib', has_lib),
        ('install_headers', has_headers),
        ('install_scripts', has_scripts),
        ('install_data', has_data),
        ('install_egg_info', lambda self: True),
    ]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/install_data.py0000644000175100001730000000531214467657412024506 0ustar00runnerdocker"""distutils.command.install_data

Implements the Distutils 'install_data' command, for installing
platform-independent data files."""

# contributed by Bastian Kleineidam

import os
from ..core import Command
from ..util import change_root, convert_path


class install_data(Command):
    description = "install data files"

    user_options = [
        (
            'install-dir=',
            'd',
            "base directory for installing data files "
            "(default: installation base dir)",
        ),
        ('root=', None, "install everything relative to this alternate root directory"),
        ('force', 'f', "force installation (overwrite existing files)"),
    ]

    boolean_options = ['force']

    def initialize_options(self):
        self.install_dir = None
        self.outfiles = []
        self.root = None
        self.force = 0
        self.data_files = self.distribution.data_files
        self.warn_dir = 1

    def finalize_options(self):
        self.set_undefined_options(
            'install',
            ('install_data', 'install_dir'),
            ('root', 'root'),
            ('force', 'force'),
        )

    def run(self):
        self.mkpath(self.install_dir)
        for f in self.data_files:
            if isinstance(f, str):
                # it's a simple file, so copy it
                f = convert_path(f)
                if self.warn_dir:
                    self.warn(
                        "setup script did not provide a directory for "
                        "'%s' -- installing right in '%s'" % (f, self.install_dir)
                    )
                (out, _) = self.copy_file(f, self.install_dir)
                self.outfiles.append(out)
            else:
                # it's a tuple with path to install to and a list of files
                dir = convert_path(f[0])
                if not os.path.isabs(dir):
                    dir = os.path.join(self.install_dir, dir)
                elif self.root:
                    dir = change_root(self.root, dir)
                self.mkpath(dir)

                if f[1] == []:
                    # If there are no files listed, the user must be
                    # trying to create an empty directory, so add the
                    # directory to the list of output files.
                    self.outfiles.append(dir)
                else:
                    # Copy files, adding them to the list of output files.
                    for data in f[1]:
                        data = convert_path(data)
                        (out, _) = self.copy_file(data, dir)
                        self.outfiles.append(out)

    def get_inputs(self):
        return self.data_files or []

    def get_outputs(self):
        return self.outfiles
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/install_egg_info.py0000644000175100001730000000534414467657412025357 0ustar00runnerdocker"""
distutils.command.install_egg_info

Implements the Distutils 'install_egg_info' command, for installing
a package's PKG-INFO metadata.
"""

import os
import sys
import re

from ..cmd import Command
from .. import dir_util
from .._log import log


class install_egg_info(Command):
    """Install an .egg-info file for the package"""

    description = "Install package's PKG-INFO metadata as an .egg-info file"
    user_options = [
        ('install-dir=', 'd', "directory to install to"),
    ]

    def initialize_options(self):
        self.install_dir = None

    @property
    def basename(self):
        """
        Allow basename to be overridden by child class.
        Ref pypa/distutils#2.
        """
        return "%s-%s-py%d.%d.egg-info" % (
            to_filename(safe_name(self.distribution.get_name())),
            to_filename(safe_version(self.distribution.get_version())),
            *sys.version_info[:2],
        )

    def finalize_options(self):
        self.set_undefined_options('install_lib', ('install_dir', 'install_dir'))
        self.target = os.path.join(self.install_dir, self.basename)
        self.outputs = [self.target]

    def run(self):
        target = self.target
        if os.path.isdir(target) and not os.path.islink(target):
            dir_util.remove_tree(target, dry_run=self.dry_run)
        elif os.path.exists(target):
            self.execute(os.unlink, (self.target,), "Removing " + target)
        elif not os.path.isdir(self.install_dir):
            self.execute(
                os.makedirs, (self.install_dir,), "Creating " + self.install_dir
            )
        log.info("Writing %s", target)
        if not self.dry_run:
            with open(target, 'w', encoding='UTF-8') as f:
                self.distribution.metadata.write_pkg_file(f)

    def get_outputs(self):
        return self.outputs


# The following routines are taken from setuptools' pkg_resources module and
# can be replaced by importing them from pkg_resources once it is included
# in the stdlib.


def safe_name(name):
    """Convert an arbitrary string to a standard distribution name

    Any runs of non-alphanumeric/. characters are replaced with a single '-'.
    """
    return re.sub('[^A-Za-z0-9.]+', '-', name)


def safe_version(version):
    """Convert an arbitrary string to a standard version string

    Spaces become dots, and all other non-alphanumeric characters become
    dashes, with runs of multiple dashes condensed to a single dash.
    """
    version = version.replace(' ', '.')
    return re.sub('[^A-Za-z0-9.]+', '-', version)


def to_filename(name):
    """Convert a project or version name to its filename-escaped form

    Any '-' characters are currently replaced with '_'.
    """
    return name.replace('-', '_')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/install_headers.py0000644000175100001730000000223414467657412025210 0ustar00runnerdocker"""distutils.command.install_headers

Implements the Distutils 'install_headers' command, to install C/C++ header
files to the Python include directory."""

from ..core import Command


# XXX force is never used
class install_headers(Command):
    description = "install C/C++ header files"

    user_options = [
        ('install-dir=', 'd', "directory to install header files to"),
        ('force', 'f', "force installation (overwrite existing files)"),
    ]

    boolean_options = ['force']

    def initialize_options(self):
        self.install_dir = None
        self.force = 0
        self.outfiles = []

    def finalize_options(self):
        self.set_undefined_options(
            'install', ('install_headers', 'install_dir'), ('force', 'force')
        )

    def run(self):
        headers = self.distribution.headers
        if not headers:
            return

        self.mkpath(self.install_dir)
        for header in headers:
            (out, _) = self.copy_file(header, self.install_dir)
            self.outfiles.append(out)

    def get_inputs(self):
        return self.distribution.headers or []

    def get_outputs(self):
        return self.outfiles
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/install_lib.py0000644000175100001730000002033114467657412024341 0ustar00runnerdocker"""distutils.command.install_lib

Implements the Distutils 'install_lib' command
(install all Python modules)."""

import os
import importlib.util
import sys

from ..core import Command
from ..errors import DistutilsOptionError


# Extension for Python source files.
PYTHON_SOURCE_EXTENSION = ".py"


class install_lib(Command):
    description = "install all Python modules (extensions and pure Python)"

    # The byte-compilation options are a tad confusing.  Here are the
    # possible scenarios:
    #   1) no compilation at all (--no-compile --no-optimize)
    #   2) compile .pyc only (--compile --no-optimize; default)
    #   3) compile .pyc and "opt-1" .pyc (--compile --optimize)
    #   4) compile "opt-1" .pyc only (--no-compile --optimize)
    #   5) compile .pyc and "opt-2" .pyc (--compile --optimize-more)
    #   6) compile "opt-2" .pyc only (--no-compile --optimize-more)
    #
    # The UI for this is two options, 'compile' and 'optimize'.
    # 'compile' is strictly boolean, and only decides whether to
    # generate .pyc files.  'optimize' is three-way (0, 1, or 2), and
    # decides both whether to generate .pyc files and what level of
    # optimization to use.

    user_options = [
        ('install-dir=', 'd', "directory to install to"),
        ('build-dir=', 'b', "build directory (where to install from)"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ('compile', 'c', "compile .py to .pyc [default]"),
        ('no-compile', None, "don't compile .py files"),
        (
            'optimize=',
            'O',
            "also compile with optimization: -O1 for \"python -O\", "
            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
        ),
        ('skip-build', None, "skip the build steps"),
    ]

    boolean_options = ['force', 'compile', 'skip-build']
    negative_opt = {'no-compile': 'compile'}

    def initialize_options(self):
        # let the 'install' command dictate our installation directory
        self.install_dir = None
        self.build_dir = None
        self.force = 0
        self.compile = None
        self.optimize = None
        self.skip_build = None

    def finalize_options(self):
        # Get all the information we need to install pure Python modules
        # from the umbrella 'install' command -- build (source) directory,
        # install (target) directory, and whether to compile .py files.
        self.set_undefined_options(
            'install',
            ('build_lib', 'build_dir'),
            ('install_lib', 'install_dir'),
            ('force', 'force'),
            ('compile', 'compile'),
            ('optimize', 'optimize'),
            ('skip_build', 'skip_build'),
        )

        if self.compile is None:
            self.compile = True
        if self.optimize is None:
            self.optimize = False

        if not isinstance(self.optimize, int):
            try:
                self.optimize = int(self.optimize)
                if self.optimize not in (0, 1, 2):
                    raise AssertionError
            except (ValueError, AssertionError):
                raise DistutilsOptionError("optimize must be 0, 1, or 2")

    def run(self):
        # Make sure we have built everything we need first
        self.build()

        # Install everything: simply dump the entire contents of the build
        # directory to the installation directory (that's the beauty of
        # having a build directory!)
        outfiles = self.install()

        # (Optionally) compile .py to .pyc
        if outfiles is not None and self.distribution.has_pure_modules():
            self.byte_compile(outfiles)

    # -- Top-level worker functions ------------------------------------
    # (called from 'run()')

    def build(self):
        if not self.skip_build:
            if self.distribution.has_pure_modules():
                self.run_command('build_py')
            if self.distribution.has_ext_modules():
                self.run_command('build_ext')

    def install(self):
        if os.path.isdir(self.build_dir):
            outfiles = self.copy_tree(self.build_dir, self.install_dir)
        else:
            self.warn(
                "'%s' does not exist -- no Python modules to install" % self.build_dir
            )
            return
        return outfiles

    def byte_compile(self, files):
        if sys.dont_write_bytecode:
            self.warn('byte-compiling is disabled, skipping.')
            return

        from ..util import byte_compile

        # Get the "--root" directory supplied to the "install" command,
        # and use it as a prefix to strip off the purported filename
        # encoded in bytecode files.  This is far from complete, but it
        # should at least generate usable bytecode in RPM distributions.
        install_root = self.get_finalized_command('install').root

        if self.compile:
            byte_compile(
                files,
                optimize=0,
                force=self.force,
                prefix=install_root,
                dry_run=self.dry_run,
            )
        if self.optimize > 0:
            byte_compile(
                files,
                optimize=self.optimize,
                force=self.force,
                prefix=install_root,
                verbose=self.verbose,
                dry_run=self.dry_run,
            )

    # -- Utility methods -----------------------------------------------

    def _mutate_outputs(self, has_any, build_cmd, cmd_option, output_dir):
        if not has_any:
            return []

        build_cmd = self.get_finalized_command(build_cmd)
        build_files = build_cmd.get_outputs()
        build_dir = getattr(build_cmd, cmd_option)

        prefix_len = len(build_dir) + len(os.sep)
        outputs = []
        for file in build_files:
            outputs.append(os.path.join(output_dir, file[prefix_len:]))

        return outputs

    def _bytecode_filenames(self, py_filenames):
        bytecode_files = []
        for py_file in py_filenames:
            # Since build_py handles package data installation, the
            # list of outputs can contain more than just .py files.
            # Make sure we only report bytecode for the .py files.
            ext = os.path.splitext(os.path.normcase(py_file))[1]
            if ext != PYTHON_SOURCE_EXTENSION:
                continue
            if self.compile:
                bytecode_files.append(
                    importlib.util.cache_from_source(py_file, optimization='')
                )
            if self.optimize > 0:
                bytecode_files.append(
                    importlib.util.cache_from_source(
                        py_file, optimization=self.optimize
                    )
                )

        return bytecode_files

    # -- External interface --------------------------------------------
    # (called by outsiders)

    def get_outputs(self):
        """Return the list of files that would be installed if this command
        were actually run.  Not affected by the "dry-run" flag or whether
        modules have actually been built yet.
        """
        pure_outputs = self._mutate_outputs(
            self.distribution.has_pure_modules(),
            'build_py',
            'build_lib',
            self.install_dir,
        )
        if self.compile:
            bytecode_outputs = self._bytecode_filenames(pure_outputs)
        else:
            bytecode_outputs = []

        ext_outputs = self._mutate_outputs(
            self.distribution.has_ext_modules(),
            'build_ext',
            'build_lib',
            self.install_dir,
        )

        return pure_outputs + bytecode_outputs + ext_outputs

    def get_inputs(self):
        """Get the list of files that are input to this command, ie. the
        files that get installed as they are named in the build tree.
        The files in this list correspond one-to-one to the output
        filenames returned by 'get_outputs()'.
        """
        inputs = []

        if self.distribution.has_pure_modules():
            build_py = self.get_finalized_command('build_py')
            inputs.extend(build_py.get_outputs())

        if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command('build_ext')
            inputs.extend(build_ext.get_outputs())

        return inputs
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/install_scripts.py0000644000175100001730000000361414467657412025267 0ustar00runnerdocker"""distutils.command.install_scripts

Implements the Distutils 'install_scripts' command, for installing
Python scripts."""

# contributed by Bastian Kleineidam

import os
from ..core import Command
from distutils._log import log
from stat import ST_MODE


class install_scripts(Command):
    description = "install scripts (Python or otherwise)"

    user_options = [
        ('install-dir=', 'd', "directory to install scripts to"),
        ('build-dir=', 'b', "build directory (where to install from)"),
        ('force', 'f', "force installation (overwrite existing files)"),
        ('skip-build', None, "skip the build steps"),
    ]

    boolean_options = ['force', 'skip-build']

    def initialize_options(self):
        self.install_dir = None
        self.force = 0
        self.build_dir = None
        self.skip_build = None

    def finalize_options(self):
        self.set_undefined_options('build', ('build_scripts', 'build_dir'))
        self.set_undefined_options(
            'install',
            ('install_scripts', 'install_dir'),
            ('force', 'force'),
            ('skip_build', 'skip_build'),
        )

    def run(self):
        if not self.skip_build:
            self.run_command('build_scripts')
        self.outfiles = self.copy_tree(self.build_dir, self.install_dir)
        if os.name == 'posix':
            # Set the executable bits (owner, group, and world) on
            # all the scripts we just installed.
            for file in self.get_outputs():
                if self.dry_run:
                    log.info("changing mode of %s", file)
                else:
                    mode = ((os.stat(file)[ST_MODE]) | 0o555) & 0o7777
                    log.info("changing mode of %s to %o", file, mode)
                    os.chmod(file, mode)

    def get_inputs(self):
        return self.distribution.scripts or []

    def get_outputs(self):
        return self.outfiles or []
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/py37compat.py0000644000175100001730000000124014467657412024051 0ustar00runnerdockerimport sys


def _pythonlib_compat():
    """
    On Python 3.7 and earlier, distutils would include the Python
    library. See pypa/distutils#9.
    """
    from distutils import sysconfig

    if not sysconfig.get_config_var('Py_ENABLED_SHARED'):
        return

    yield 'python{}.{}{}'.format(
        sys.hexversion >> 24,
        (sys.hexversion >> 16) & 0xFF,
        sysconfig.get_config_var('ABIFLAGS'),
    )


def compose(f1, f2):
    return lambda *args, **kwargs: f1(f2(*args, **kwargs))


pythonlib = (
    compose(list, _pythonlib_compat)
    if sys.version_info < (3, 8)
    and sys.platform != 'darwin'
    and sys.platform[:3] != 'aix'
    else list
)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/register.py0000644000175100001730000002705114467657412023677 0ustar00runnerdocker"""distutils.command.register

Implements the Distutils 'register' command (register with the repository).
"""

# created 2002/10/21, Richard Jones

import getpass
import io
import logging
import urllib.parse
import urllib.request
from warnings import warn

from ..core import PyPIRCCommand
from distutils._log import log


class register(PyPIRCCommand):
    description = "register the distribution with the Python package index"
    user_options = PyPIRCCommand.user_options + [
        ('list-classifiers', None, 'list the valid Trove classifiers'),
        (
            'strict',
            None,
            'Will stop the registering if the meta-data are not fully compliant',
        ),
    ]
    boolean_options = PyPIRCCommand.boolean_options + [
        'verify',
        'list-classifiers',
        'strict',
    ]

    sub_commands = [('check', lambda self: True)]

    def initialize_options(self):
        PyPIRCCommand.initialize_options(self)
        self.list_classifiers = 0
        self.strict = 0

    def finalize_options(self):
        PyPIRCCommand.finalize_options(self)
        # setting options for the `check` subcommand
        check_options = {
            'strict': ('register', self.strict),
            'restructuredtext': ('register', 1),
        }
        self.distribution.command_options['check'] = check_options

    def run(self):
        self.finalize_options()
        self._set_config()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        if self.dry_run:
            self.verify_metadata()
        elif self.list_classifiers:
            self.classifiers()
        else:
            self.send_metadata()

    def check_metadata(self):
        """Deprecated API."""
        warn(
            "distutils.command.register.check_metadata is deprecated; "
            "use the check command instead",
            DeprecationWarning,
        )
        check = self.distribution.get_command_obj('check')
        check.ensure_finalized()
        check.strict = self.strict
        check.restructuredtext = 1
        check.run()

    def _set_config(self):
        '''Reads the configuration file and set attributes.'''
        config = self._read_pypirc()
        if config != {}:
            self.username = config['username']
            self.password = config['password']
            self.repository = config['repository']
            self.realm = config['realm']
            self.has_config = True
        else:
            if self.repository not in ('pypi', self.DEFAULT_REPOSITORY):
                raise ValueError('%s not found in .pypirc' % self.repository)
            if self.repository == 'pypi':
                self.repository = self.DEFAULT_REPOSITORY
            self.has_config = False

    def classifiers(self):
        '''Fetch the list of classifiers from the server.'''
        url = self.repository + '?:action=list_classifiers'
        response = urllib.request.urlopen(url)
        log.info(self._read_pypi_response(response))

    def verify_metadata(self):
        '''Send the metadata to the package index server to be checked.'''
        # send the info to the server and report the result
        (code, result) = self.post_to_server(self.build_post_data('verify'))
        log.info('Server response (%s): %s', code, result)

    def send_metadata(self):  # noqa: C901
        '''Send the metadata to the package index server.

        Well, do the following:
        1. figure who the user is, and then
        2. send the data as a Basic auth'ed POST.

        First we try to read the username/password from $HOME/.pypirc,
        which is a ConfigParser-formatted file with a section
        [distutils] containing username and password entries (both
        in clear text). Eg:

            [distutils]
            index-servers =
                pypi

            [pypi]
            username: fred
            password: sekrit

        Otherwise, to figure who the user is, we offer the user three
        choices:

         1. use existing login,
         2. register as a new user, or
         3. set the password to a random string and email the user.

        '''
        # see if we can short-cut and get the username/password from the
        # config
        if self.has_config:
            choice = '1'
            username = self.username
            password = self.password
        else:
            choice = 'x'
            username = password = ''

        # get the user's login info
        choices = '1 2 3 4'.split()
        while choice not in choices:
            self.announce(
                '''\
We need to know who you are, so please choose either:
 1. use your existing login,
 2. register as a new user,
 3. have the server generate a new password for you (and email it to you), or
 4. quit
Your selection [default 1]: ''',
                logging.INFO,
            )
            choice = input()
            if not choice:
                choice = '1'
            elif choice not in choices:
                print('Please choose one of the four options!')

        if choice == '1':
            # get the username and password
            while not username:
                username = input('Username: ')
            while not password:
                password = getpass.getpass('Password: ')

            # set up the authentication
            auth = urllib.request.HTTPPasswordMgr()
            host = urllib.parse.urlparse(self.repository)[1]
            auth.add_password(self.realm, host, username, password)
            # send the info to the server and report the result
            code, result = self.post_to_server(self.build_post_data('submit'), auth)
            self.announce('Server response ({}): {}'.format(code, result), logging.INFO)

            # possibly save the login
            if code == 200:
                if self.has_config:
                    # sharing the password in the distribution instance
                    # so the upload command can reuse it
                    self.distribution.password = password
                else:
                    self.announce(
                        (
                            'I can store your PyPI login so future '
                            'submissions will be faster.'
                        ),
                        logging.INFO,
                    )
                    self.announce(
                        '(the login will be stored in %s)' % self._get_rc_file(),
                        logging.INFO,
                    )
                    choice = 'X'
                    while choice.lower() not in 'yn':
                        choice = input('Save your login (y/N)?')
                        if not choice:
                            choice = 'n'
                    if choice.lower() == 'y':
                        self._store_pypirc(username, password)

        elif choice == '2':
            data = {':action': 'user'}
            data['name'] = data['password'] = data['email'] = ''
            data['confirm'] = None
            while not data['name']:
                data['name'] = input('Username: ')
            while data['password'] != data['confirm']:
                while not data['password']:
                    data['password'] = getpass.getpass('Password: ')
                while not data['confirm']:
                    data['confirm'] = getpass.getpass(' Confirm: ')
                if data['password'] != data['confirm']:
                    data['password'] = ''
                    data['confirm'] = None
                    print("Password and confirm don't match!")
            while not data['email']:
                data['email'] = input('   EMail: ')
            code, result = self.post_to_server(data)
            if code != 200:
                log.info('Server response (%s): %s', code, result)
            else:
                log.info('You will receive an email shortly.')
                log.info('Follow the instructions in it to ' 'complete registration.')
        elif choice == '3':
            data = {':action': 'password_reset'}
            data['email'] = ''
            while not data['email']:
                data['email'] = input('Your email address: ')
            code, result = self.post_to_server(data)
            log.info('Server response (%s): %s', code, result)

    def build_post_data(self, action):
        # figure the data to send - the metadata plus some additional
        # information used by the package server
        meta = self.distribution.metadata
        data = {
            ':action': action,
            'metadata_version': '1.0',
            'name': meta.get_name(),
            'version': meta.get_version(),
            'summary': meta.get_description(),
            'home_page': meta.get_url(),
            'author': meta.get_contact(),
            'author_email': meta.get_contact_email(),
            'license': meta.get_licence(),
            'description': meta.get_long_description(),
            'keywords': meta.get_keywords(),
            'platform': meta.get_platforms(),
            'classifiers': meta.get_classifiers(),
            'download_url': meta.get_download_url(),
            # PEP 314
            'provides': meta.get_provides(),
            'requires': meta.get_requires(),
            'obsoletes': meta.get_obsoletes(),
        }
        if data['provides'] or data['requires'] or data['obsoletes']:
            data['metadata_version'] = '1.1'
        return data

    def post_to_server(self, data, auth=None):  # noqa: C901
        '''Post a query to the server, and return a string response.'''
        if 'name' in data:
            self.announce(
                'Registering {} to {}'.format(data['name'], self.repository),
                logging.INFO,
            )
        # Build up the MIME payload for the urllib2 POST data
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = '\n--' + boundary
        end_boundary = sep_boundary + '--'
        body = io.StringIO()
        for key, value in data.items():
            # handle multiple entries for the same name
            if type(value) not in (type([]), type(())):
                value = [value]
            for value in value:
                value = str(value)
                body.write(sep_boundary)
                body.write('\nContent-Disposition: form-data; name="%s"' % key)
                body.write("\n\n")
                body.write(value)
                if value and value[-1] == '\r':
                    body.write('\n')  # write an extra newline (lurve Macs)
        body.write(end_boundary)
        body.write("\n")
        body = body.getvalue().encode("utf-8")

        # build the Request
        headers = {
            'Content-type': 'multipart/form-data; boundary=%s; charset=utf-8'
            % boundary,
            'Content-length': str(len(body)),
        }
        req = urllib.request.Request(self.repository, body, headers)

        # handle HTTP and include the Basic Auth handler
        opener = urllib.request.build_opener(
            urllib.request.HTTPBasicAuthHandler(password_mgr=auth)
        )
        data = ''
        try:
            result = opener.open(req)
        except urllib.error.HTTPError as e:
            if self.show_response:
                data = e.fp.read()
            result = e.code, e.msg
        except urllib.error.URLError as e:
            result = 500, str(e)
        else:
            if self.show_response:
                data = self._read_pypi_response(result)
            result = 200, 'OK'
        if self.show_response:
            msg = '\n'.join(('-' * 75, data, '-' * 75))
            self.announce(msg, logging.INFO)
        return result
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/sdist.py0000644000175100001730000004544014467657412023203 0ustar00runnerdocker"""distutils.command.sdist

Implements the Distutils 'sdist' command (create a source distribution)."""

import os
import sys
from glob import glob
from warnings import warn

from ..core import Command
from distutils import dir_util
from distutils import file_util
from distutils import archive_util
from ..text_file import TextFile
from ..filelist import FileList
from distutils._log import log
from ..util import convert_path
from ..errors import DistutilsOptionError, DistutilsTemplateError


def show_formats():
    """Print all possible values for the 'formats' option (used by
    the "--help-formats" command-line option).
    """
    from ..fancy_getopt import FancyGetopt
    from ..archive_util import ARCHIVE_FORMATS

    formats = []
    for format in ARCHIVE_FORMATS.keys():
        formats.append(("formats=" + format, None, ARCHIVE_FORMATS[format][2]))
    formats.sort()
    FancyGetopt(formats).print_help("List of available source distribution formats:")


class sdist(Command):
    description = "create a source distribution (tarball, zip file, etc.)"

    def checking_metadata(self):
        """Callable used for the check sub-command.

        Placed here so user_options can view it"""
        return self.metadata_check

    user_options = [
        ('template=', 't', "name of manifest template file [default: MANIFEST.in]"),
        ('manifest=', 'm', "name of manifest file [default: MANIFEST]"),
        (
            'use-defaults',
            None,
            "include the default file set in the manifest "
            "[default; disable with --no-defaults]",
        ),
        ('no-defaults', None, "don't include the default file set"),
        (
            'prune',
            None,
            "specifically exclude files/directories that should not be "
            "distributed (build tree, RCS/CVS dirs, etc.) "
            "[default; disable with --no-prune]",
        ),
        ('no-prune', None, "don't automatically exclude anything"),
        (
            'manifest-only',
            'o',
            "just regenerate the manifest and then stop " "(implies --force-manifest)",
        ),
        (
            'force-manifest',
            'f',
            "forcibly regenerate the manifest and carry on as usual. "
            "Deprecated: now the manifest is always regenerated.",
        ),
        ('formats=', None, "formats for source distribution (comma-separated list)"),
        (
            'keep-temp',
            'k',
            "keep the distribution tree around after creating " + "archive file(s)",
        ),
        (
            'dist-dir=',
            'd',
            "directory to put the source distribution archive(s) in " "[default: dist]",
        ),
        (
            'metadata-check',
            None,
            "Ensure that all required elements of meta-data "
            "are supplied. Warn if any missing. [default]",
        ),
        (
            'owner=',
            'u',
            "Owner name used when creating a tar file [default: current user]",
        ),
        (
            'group=',
            'g',
            "Group name used when creating a tar file [default: current group]",
        ),
    ]

    boolean_options = [
        'use-defaults',
        'prune',
        'manifest-only',
        'force-manifest',
        'keep-temp',
        'metadata-check',
    ]

    help_options = [
        ('help-formats', None, "list available distribution formats", show_formats),
    ]

    negative_opt = {'no-defaults': 'use-defaults', 'no-prune': 'prune'}

    sub_commands = [('check', checking_metadata)]

    READMES = ('README', 'README.txt', 'README.rst')

    def initialize_options(self):
        # 'template' and 'manifest' are, respectively, the names of
        # the manifest template and manifest file.
        self.template = None
        self.manifest = None

        # 'use_defaults': if true, we will include the default file set
        # in the manifest
        self.use_defaults = 1
        self.prune = 1

        self.manifest_only = 0
        self.force_manifest = 0

        self.formats = ['gztar']
        self.keep_temp = 0
        self.dist_dir = None

        self.archive_files = None
        self.metadata_check = 1
        self.owner = None
        self.group = None

    def finalize_options(self):
        if self.manifest is None:
            self.manifest = "MANIFEST"
        if self.template is None:
            self.template = "MANIFEST.in"

        self.ensure_string_list('formats')

        bad_format = archive_util.check_archive_formats(self.formats)
        if bad_format:
            raise DistutilsOptionError("unknown archive format '%s'" % bad_format)

        if self.dist_dir is None:
            self.dist_dir = "dist"

    def run(self):
        # 'filelist' contains the list of files that will make up the
        # manifest
        self.filelist = FileList()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        # Do whatever it takes to get the list of files to process
        # (process the manifest template, read an existing manifest,
        # whatever).  File list is accumulated in 'self.filelist'.
        self.get_file_list()

        # If user just wanted us to regenerate the manifest, stop now.
        if self.manifest_only:
            return

        # Otherwise, go ahead and create the source distribution tarball,
        # or zipfile, or whatever.
        self.make_distribution()

    def check_metadata(self):
        """Deprecated API."""
        warn(
            "distutils.command.sdist.check_metadata is deprecated, \
              use the check command instead",
            PendingDeprecationWarning,
        )
        check = self.distribution.get_command_obj('check')
        check.ensure_finalized()
        check.run()

    def get_file_list(self):
        """Figure out the list of files to include in the source
        distribution, and put it in 'self.filelist'.  This might involve
        reading the manifest template (and writing the manifest), or just
        reading the manifest, or just using the default file set -- it all
        depends on the user's options.
        """
        # new behavior when using a template:
        # the file list is recalculated every time because
        # even if MANIFEST.in or setup.py are not changed
        # the user might have added some files in the tree that
        # need to be included.
        #
        #  This makes --force the default and only behavior with templates.
        template_exists = os.path.isfile(self.template)
        if not template_exists and self._manifest_is_not_generated():
            self.read_manifest()
            self.filelist.sort()
            self.filelist.remove_duplicates()
            return

        if not template_exists:
            self.warn(
                ("manifest template '%s' does not exist " + "(using default file list)")
                % self.template
            )
        self.filelist.findall()

        if self.use_defaults:
            self.add_defaults()

        if template_exists:
            self.read_template()

        if self.prune:
            self.prune_file_list()

        self.filelist.sort()
        self.filelist.remove_duplicates()
        self.write_manifest()

    def add_defaults(self):
        """Add all the default files to self.filelist:
          - README or README.txt
          - setup.py
          - tests/test*.py and test/test*.py
          - all pure Python modules mentioned in setup script
          - all files pointed by package_data (build_py)
          - all files defined in data_files.
          - all files defined as scripts.
          - all C sources listed as part of extensions or C libraries
            in the setup script (doesn't catch C headers!)
        Warns if (README or README.txt) or setup.py are missing; everything
        else is optional.
        """
        self._add_defaults_standards()
        self._add_defaults_optional()
        self._add_defaults_python()
        self._add_defaults_data_files()
        self._add_defaults_ext()
        self._add_defaults_c_libs()
        self._add_defaults_scripts()

    @staticmethod
    def _cs_path_exists(fspath):
        """
        Case-sensitive path existence check

        >>> sdist._cs_path_exists(__file__)
        True
        >>> sdist._cs_path_exists(__file__.upper())
        False
        """
        if not os.path.exists(fspath):
            return False
        # make absolute so we always have a directory
        abspath = os.path.abspath(fspath)
        directory, filename = os.path.split(abspath)
        return filename in os.listdir(directory)

    def _add_defaults_standards(self):
        standards = [self.READMES, self.distribution.script_name]
        for fn in standards:
            if isinstance(fn, tuple):
                alts = fn
                got_it = False
                for fn in alts:
                    if self._cs_path_exists(fn):
                        got_it = True
                        self.filelist.append(fn)
                        break

                if not got_it:
                    self.warn(
                        "standard file not found: should have one of " + ', '.join(alts)
                    )
            else:
                if self._cs_path_exists(fn):
                    self.filelist.append(fn)
                else:
                    self.warn("standard file '%s' not found" % fn)

    def _add_defaults_optional(self):
        optional = ['tests/test*.py', 'test/test*.py', 'setup.cfg']
        for pattern in optional:
            files = filter(os.path.isfile, glob(pattern))
            self.filelist.extend(files)

    def _add_defaults_python(self):
        # build_py is used to get:
        #  - python modules
        #  - files defined in package_data
        build_py = self.get_finalized_command('build_py')

        # getting python files
        if self.distribution.has_pure_modules():
            self.filelist.extend(build_py.get_source_files())

        # getting package_data files
        # (computed in build_py.data_files by build_py.finalize_options)
        for pkg, src_dir, build_dir, filenames in build_py.data_files:
            for filename in filenames:
                self.filelist.append(os.path.join(src_dir, filename))

    def _add_defaults_data_files(self):
        # getting distribution.data_files
        if self.distribution.has_data_files():
            for item in self.distribution.data_files:
                if isinstance(item, str):
                    # plain file
                    item = convert_path(item)
                    if os.path.isfile(item):
                        self.filelist.append(item)
                else:
                    # a (dirname, filenames) tuple
                    dirname, filenames = item
                    for f in filenames:
                        f = convert_path(f)
                        if os.path.isfile(f):
                            self.filelist.append(f)

    def _add_defaults_ext(self):
        if self.distribution.has_ext_modules():
            build_ext = self.get_finalized_command('build_ext')
            self.filelist.extend(build_ext.get_source_files())

    def _add_defaults_c_libs(self):
        if self.distribution.has_c_libraries():
            build_clib = self.get_finalized_command('build_clib')
            self.filelist.extend(build_clib.get_source_files())

    def _add_defaults_scripts(self):
        if self.distribution.has_scripts():
            build_scripts = self.get_finalized_command('build_scripts')
            self.filelist.extend(build_scripts.get_source_files())

    def read_template(self):
        """Read and parse manifest template file named by self.template.

        (usually "MANIFEST.in") The parsing and processing is done by
        'self.filelist', which updates itself accordingly.
        """
        log.info("reading manifest template '%s'", self.template)
        template = TextFile(
            self.template,
            strip_comments=1,
            skip_blanks=1,
            join_lines=1,
            lstrip_ws=1,
            rstrip_ws=1,
            collapse_join=1,
        )

        try:
            while True:
                line = template.readline()
                if line is None:  # end of file
                    break

                try:
                    self.filelist.process_template_line(line)
                # the call above can raise a DistutilsTemplateError for
                # malformed lines, or a ValueError from the lower-level
                # convert_path function
                except (DistutilsTemplateError, ValueError) as msg:
                    self.warn(
                        "%s, line %d: %s"
                        % (template.filename, template.current_line, msg)
                    )
        finally:
            template.close()

    def prune_file_list(self):
        """Prune off branches that might slip into the file list as created
        by 'read_template()', but really don't belong there:
          * the build tree (typically "build")
          * the release tree itself (only an issue if we ran "sdist"
            previously with --keep-temp, or it aborted)
          * any RCS, CVS, .svn, .hg, .git, .bzr, _darcs directories
        """
        build = self.get_finalized_command('build')
        base_dir = self.distribution.get_fullname()

        self.filelist.exclude_pattern(None, prefix=build.build_base)
        self.filelist.exclude_pattern(None, prefix=base_dir)

        if sys.platform == 'win32':
            seps = r'/|\\'
        else:
            seps = '/'

        vcs_dirs = ['RCS', 'CVS', r'\.svn', r'\.hg', r'\.git', r'\.bzr', '_darcs']
        vcs_ptrn = r'(^|{})({})({}).*'.format(seps, '|'.join(vcs_dirs), seps)
        self.filelist.exclude_pattern(vcs_ptrn, is_regex=1)

    def write_manifest(self):
        """Write the file list in 'self.filelist' (presumably as filled in
        by 'add_defaults()' and 'read_template()') to the manifest file
        named by 'self.manifest'.
        """
        if self._manifest_is_not_generated():
            log.info(
                "not writing to manually maintained "
                "manifest file '%s'" % self.manifest
            )
            return

        content = self.filelist.files[:]
        content.insert(0, '# file GENERATED by distutils, do NOT edit')
        self.execute(
            file_util.write_file,
            (self.manifest, content),
            "writing manifest file '%s'" % self.manifest,
        )

    def _manifest_is_not_generated(self):
        # check for special comment used in 3.1.3 and higher
        if not os.path.isfile(self.manifest):
            return False

        fp = open(self.manifest)
        try:
            first_line = fp.readline()
        finally:
            fp.close()
        return first_line != '# file GENERATED by distutils, do NOT edit\n'

    def read_manifest(self):
        """Read the manifest file (named by 'self.manifest') and use it to
        fill in 'self.filelist', the list of files to include in the source
        distribution.
        """
        log.info("reading manifest file '%s'", self.manifest)
        with open(self.manifest) as manifest:
            for line in manifest:
                # ignore comments and blank lines
                line = line.strip()
                if line.startswith('#') or not line:
                    continue
                self.filelist.append(line)

    def make_release_tree(self, base_dir, files):
        """Create the directory tree that will become the source
        distribution archive.  All directories implied by the filenames in
        'files' are created under 'base_dir', and then we hard link or copy
        (if hard linking is unavailable) those files into place.
        Essentially, this duplicates the developer's source tree, but in a
        directory named after the distribution, containing only the files
        to be distributed.
        """
        # Create all the directories under 'base_dir' necessary to
        # put 'files' there; the 'mkpath()' is just so we don't die
        # if the manifest happens to be empty.
        self.mkpath(base_dir)
        dir_util.create_tree(base_dir, files, dry_run=self.dry_run)

        # And walk over the list of files, either making a hard link (if
        # os.link exists) to each one that doesn't already exist in its
        # corresponding location under 'base_dir', or copying each file
        # that's out-of-date in 'base_dir'.  (Usually, all files will be
        # out-of-date, because by default we blow away 'base_dir' when
        # we're done making the distribution archives.)

        if hasattr(os, 'link'):  # can make hard links on this system
            link = 'hard'
            msg = "making hard links in %s..." % base_dir
        else:  # nope, have to copy
            link = None
            msg = "copying files to %s..." % base_dir

        if not files:
            log.warning("no files to distribute -- empty manifest?")
        else:
            log.info(msg)
        for file in files:
            if not os.path.isfile(file):
                log.warning("'%s' not a regular file -- skipping", file)
            else:
                dest = os.path.join(base_dir, file)
                self.copy_file(file, dest, link=link)

        self.distribution.metadata.write_pkg_info(base_dir)

    def make_distribution(self):
        """Create the source distribution(s).  First, we create the release
        tree with 'make_release_tree()'; then, we create all required
        archive files (according to 'self.formats') from the release tree.
        Finally, we clean up by blowing away the release tree (unless
        'self.keep_temp' is true).  The list of archive files created is
        stored so it can be retrieved later by 'get_archive_files()'.
        """
        # Don't warn about missing meta-data here -- should be (and is!)
        # done elsewhere.
        base_dir = self.distribution.get_fullname()
        base_name = os.path.join(self.dist_dir, base_dir)

        self.make_release_tree(base_dir, self.filelist.files)
        archive_files = []  # remember names of files we create
        # tar archive must be created last to avoid overwrite and remove
        if 'tar' in self.formats:
            self.formats.append(self.formats.pop(self.formats.index('tar')))

        for fmt in self.formats:
            file = self.make_archive(
                base_name, fmt, base_dir=base_dir, owner=self.owner, group=self.group
            )
            archive_files.append(file)
            self.distribution.dist_files.append(('sdist', '', file))

        self.archive_files = archive_files

        if not self.keep_temp:
            dir_util.remove_tree(base_dir, dry_run=self.dry_run)

    def get_archive_files(self):
        """Return the list of archive files created when the command
        was run, or None if the command hasn't run yet.
        """
        return self.archive_files
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/upload.py0000644000175100001730000001650314467657412023337 0ustar00runnerdocker"""
distutils.command.upload

Implements the Distutils 'upload' subcommand (upload package to a package
index).
"""

import os
import io
import hashlib
import logging
from base64 import standard_b64encode
from urllib.request import urlopen, Request, HTTPError
from urllib.parse import urlparse
from ..errors import DistutilsError, DistutilsOptionError
from ..core import PyPIRCCommand
from ..spawn import spawn


# PyPI Warehouse supports MD5, SHA256, and Blake2 (blake2-256)
# https://bugs.python.org/issue40698
_FILE_CONTENT_DIGESTS = {
    "md5_digest": getattr(hashlib, "md5", None),
    "sha256_digest": getattr(hashlib, "sha256", None),
    "blake2_256_digest": getattr(hashlib, "blake2b", None),
}


class upload(PyPIRCCommand):
    description = "upload binary package to PyPI"

    user_options = PyPIRCCommand.user_options + [
        ('sign', 's', 'sign files to upload using gpg'),
        ('identity=', 'i', 'GPG identity used to sign files'),
    ]

    boolean_options = PyPIRCCommand.boolean_options + ['sign']

    def initialize_options(self):
        PyPIRCCommand.initialize_options(self)
        self.username = ''
        self.password = ''
        self.show_response = 0
        self.sign = False
        self.identity = None

    def finalize_options(self):
        PyPIRCCommand.finalize_options(self)
        if self.identity and not self.sign:
            raise DistutilsOptionError("Must use --sign for --identity to have meaning")
        config = self._read_pypirc()
        if config != {}:
            self.username = config['username']
            self.password = config['password']
            self.repository = config['repository']
            self.realm = config['realm']

        # getting the password from the distribution
        # if previously set by the register command
        if not self.password and self.distribution.password:
            self.password = self.distribution.password

    def run(self):
        if not self.distribution.dist_files:
            msg = (
                "Must create and upload files in one command "
                "(e.g. setup.py sdist upload)"
            )
            raise DistutilsOptionError(msg)
        for command, pyversion, filename in self.distribution.dist_files:
            self.upload_file(command, pyversion, filename)

    def upload_file(self, command, pyversion, filename):  # noqa: C901
        # Makes sure the repository URL is compliant
        schema, netloc, url, params, query, fragments = urlparse(self.repository)
        if params or query or fragments:
            raise AssertionError("Incompatible url %s" % self.repository)

        if schema not in ('http', 'https'):
            raise AssertionError("unsupported schema " + schema)

        # Sign if requested
        if self.sign:
            gpg_args = ["gpg", "--detach-sign", "-a", filename]
            if self.identity:
                gpg_args[2:2] = ["--local-user", self.identity]
            spawn(gpg_args, dry_run=self.dry_run)

        # Fill in the data - send all the meta-data in case we need to
        # register a new release
        f = open(filename, 'rb')
        try:
            content = f.read()
        finally:
            f.close()

        meta = self.distribution.metadata
        data = {
            # action
            ':action': 'file_upload',
            'protocol_version': '1',
            # identify release
            'name': meta.get_name(),
            'version': meta.get_version(),
            # file content
            'content': (os.path.basename(filename), content),
            'filetype': command,
            'pyversion': pyversion,
            # additional meta-data
            'metadata_version': '1.0',
            'summary': meta.get_description(),
            'home_page': meta.get_url(),
            'author': meta.get_contact(),
            'author_email': meta.get_contact_email(),
            'license': meta.get_licence(),
            'description': meta.get_long_description(),
            'keywords': meta.get_keywords(),
            'platform': meta.get_platforms(),
            'classifiers': meta.get_classifiers(),
            'download_url': meta.get_download_url(),
            # PEP 314
            'provides': meta.get_provides(),
            'requires': meta.get_requires(),
            'obsoletes': meta.get_obsoletes(),
        }

        data['comment'] = ''

        # file content digests
        for digest_name, digest_cons in _FILE_CONTENT_DIGESTS.items():
            if digest_cons is None:
                continue
            try:
                data[digest_name] = digest_cons(content).hexdigest()
            except ValueError:
                # hash digest not available or blocked by security policy
                pass

        if self.sign:
            with open(filename + ".asc", "rb") as f:
                data['gpg_signature'] = (os.path.basename(filename) + ".asc", f.read())

        # set up the authentication
        user_pass = (self.username + ":" + self.password).encode('ascii')
        # The exact encoding of the authentication string is debated.
        # Anyway PyPI only accepts ascii for both username or password.
        auth = "Basic " + standard_b64encode(user_pass).decode('ascii')

        # Build up the MIME payload for the POST data
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = b'\r\n--' + boundary.encode('ascii')
        end_boundary = sep_boundary + b'--\r\n'
        body = io.BytesIO()
        for key, value in data.items():
            title = '\r\nContent-Disposition: form-data; name="%s"' % key
            # handle multiple entries for the same name
            if not isinstance(value, list):
                value = [value]
            for value in value:
                if type(value) is tuple:
                    title += '; filename="%s"' % value[0]
                    value = value[1]
                else:
                    value = str(value).encode('utf-8')
                body.write(sep_boundary)
                body.write(title.encode('utf-8'))
                body.write(b"\r\n\r\n")
                body.write(value)
        body.write(end_boundary)
        body = body.getvalue()

        msg = "Submitting {} to {}".format(filename, self.repository)
        self.announce(msg, logging.INFO)

        # build the Request
        headers = {
            'Content-type': 'multipart/form-data; boundary=%s' % boundary,
            'Content-length': str(len(body)),
            'Authorization': auth,
        }

        request = Request(self.repository, data=body, headers=headers)
        # send the data
        try:
            result = urlopen(request)
            status = result.getcode()
            reason = result.msg
        except HTTPError as e:
            status = e.code
            reason = e.msg
        except OSError as e:
            self.announce(str(e), logging.ERROR)
            raise

        if status == 200:
            self.announce(
                'Server response ({}): {}'.format(status, reason), logging.INFO
            )
            if self.show_response:
                text = self._read_pypi_response(result)
                msg = '\n'.join(('-' * 75, text, '-' * 75))
                self.announce(msg, logging.INFO)
        else:
            msg = 'Upload failed ({}): {}'.format(status, reason)
            self.announce(msg, logging.ERROR)
            raise DistutilsError(msg)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/wininst-10.0-amd64.exe0000644000175100001730000066200014467657412025163 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$,fBfBfBv(fBfBfBfBfBfBfCDfBhfBfBfBRichfBPEdܯO#
F@e`@.textDF `.rdataL`J@@.data\@@.pdata4@@.rsrcP@@Ht9t9/\DˆHuH\$Hl$Ht$WH IHHH;\H|HHtuH4Ru/3H*RuHtHJUHL
Hֹ@u!QHtHULƹ\HmH\$0Hl$8Ht$@H _H\$Hl$Ht$WATAUHPH$EMHDHd$0E3E3HD$(l$ QHHQuLIHuwPt
,QFHtcH׹ӅtKHd$0E3E3HD$(D$ PHHu)HtHHTLǹ
H׹3Ht
H׹$$LD$@YPLL$@LD$@HT$@HIPHEuCPHd$(E33EADl$ /PHHPHuHrHSPHd$ E3E3AQHOHHOHuH3H.SHL\$PI[ Ik(Is0IA]A\_H\$Hl$WHAHHA3HL$ DBXzGH\$ D$($L@SHL$ DKWSD$8Hl$02UH$tHt2HRHL$ iW;tHtHRD3HL$ mtHtHRD3HNL$I[IkI_EuLc$9zH\$UVWATAUAVAWH$`HHz.H3HLIEADE+dED+LHT$xAA|PKHL$HB Ll$`t3E3Dl$@fE;lHcHHc~*B'LcL>PKuA>PKuN .HcHHD$PFFIFH;T$DIVHIcHHUHDII+HD$p
HuH3H}HUHHр|\HT$XtH}HHQfGHM
MHcHD
HD$hHD$HH8t?LI9HT$PH3HLAI	IMILL$HI9uMFHT$PHMH|Ll$XHM:H3H}H|$hHB|)\Ll$`tXFDNLl$0fD$(FHUL3fD$ Ht*NEFDNHT$pLl$(L$ H3MtDL$@EDHAAՋL$@ADL$@;T$DLD$xE3HT$HMIJ\HNHHH>LD$ HNH\H=>t3H=*'HT$ HMitH
rH
/lHPNGH&HcE3H3DHT$0}>tHT$0H
1NonH
oHMLD$ t[3H$@H3ByH$`HP_H\$UH$@HH(H3HHeHd$hd$XHd$xHd$PHd$`3HUJyHOH
oDZHD$XLMLEHD$@HD$hHNHD$8HD$xHHD$0HEHD$(HD$pHD$ Zu3HD$PL
ȌH
3DHD$ IyH>N_HL$PLD$`H0HyHM9HL$PHUHyHMHL$PHUHP8yHgMHUHtHL$PHPXyH#MHT$hHt#HL$PDD$XHyHLHT$xHtHL$PHPHyHLLD$pHEA33D$(HD$ EHL$`HHUDP0yGLD$pH
FmHLDYHL$`HtHPHL$PHtHPXHcHL$`HPHL$PHP7HH
KkHH3vH$H]LHHIKHMK IKMCHLHvXu3-FDL$`LD$hHT$0HFH
L)kHHH
m"H%vhH\$H|$UH$PHH$H3HHLkHpLHD$ [FHoH>DHD
6jDgHKHL$0FLL$ LEHT$0HAt#LL$ LEHT$0HAt3?3HH}HHHfG3H}3ɊHDuHMCHH3tL$I[I{ I]H\$UVWATAUAVAWH H%LHTCHKHHACHKHL.CHKHHCHKHLCHaKHHHD$hBH9KHLBHKHLB3HD$pHHMMHMMH
JHHt[HJHHpJHH>fH-!HHiHc3HHAHHLAH rHl$hHD$pH-thL%UHe3L-}UH\$`H A_A^A]A\_^]@USVWATAUAVAWHHl$ H"H3HE`HHJMMcHHMAHJHHEAHJHLmAHJHHHE VAHIHLHE?AHMHIH+AHMHIHEAHMH[IHE(A3H9MMHM{HrH9M(hH_H9MUHE8=3Hu H~ILHH`FH
fLDI!CUHMH
63A!k3E~0L56M+IJ0Htr3IHI;|LuL%c6AIA3E~IHt5yHI;|HU0λ}uMDEDA@HcHAH;w
HH"H+H|$ H~HHf8
U A֋SHM`H3pHexA_A^A]A\_^[]H\$Hl$Ht$WATAUAVAWHPI!DL33IM$Hd$0E3DHȺD$(LD$ >H؋==H$*=HӋHD$@=Hӹ=H
QHHtMEIHHϋ<赁HGHH`H$<HT$@<3H7=;s
3H#=GHcwE3HHtDE3E33HD$=HL$DHLl$ =D$HE,H=I=L\$PI[0Ik8Is@IA_A^A]A\_HHXHhHpHx ATAUAVH LHFLL=HFIL9=HRFIH&=HOFIH=HFIH=HMt;Ht6Ht1Ht,Ht'H
`AIXIՋ؅t׋H\$@Hl$HHt$PH|$XH A^A]A\H\$Hl$VWATAUAVHHH3H$H33M"Hd$0E3EAHD$(LD$ [<H:L:H֋Lu:H֋j:H
kNBHHu-<HEHL$PD=HL$PHH2Hˋ:Iչ:Iֹ93H:DG-HcDuHHtgd$@HEH+Š
H„uE3E33H;Hd$ HS,LL$@DH:D\$@HA,AHGtH
DH ;I:H$H3%lL$I[8Ik@IA^A]A\_^H\$WH`HH3H$P3HtEHD$0D$(HD$@DD3ҹHD$ 8HT$@HL$PDHL$@8D$PHL$P/:LHcH+HLPHH
]LDHT$PA;3H$PH3@kH$H`_LISMCMK VWH8HH3H$ IsLHL$ L蟂tmt$H
`HHCH
_Hc~DE3A;L$XH
_LǺ;9HT$ C:L-CHT$ HA0:yH
\`HtHBL$XzH$X.赀HtBH=BHu/H$X| H
`HtL$XHwByH$ H3iH8_^HHXHhHp WH@H`E3H@EA@8HHu3iHT$`H6Hd$(d$ E33HEA7HH7HtHd$ E3E3AQH7HH7.HH\$PHl$XHt$hH@_H\$WH0H=JHtQH=^uG9LJd$(EH
IPHMAHHT$ S5HHH^9H\$@H0_@SUVWATAUAVH`H#H3H$PL$E3+TM+TMuM1"HcHف|PK;{V4tH#A3D9stHcCHH+HcCH+H
I+SH{+AHcH+pHHHT$@4H@HL$@LE34tgDE3Lt$0AHHfDt$(fDt$ {HHtPLcHH}|H3HHH觺HIEI4$55H?3H$PH3fH`A^A]A\_^][HhHL$07HL$07HL$0E3E33D$ 7uHh@SUVWHHQH3H$HtX7&HT$pP7HJ7E3ɋиgfffE33H
~?HL$h3ɉL$`L$XL$PL$HL$@L$8L$0D$(D$ 2HH2HHv2H3H=CL
CPHDHɉL$ HO2HI2H3P
H=qCL
jCDHHɉL$ H2HH1H
2HT$pHG63H$H3
eH_^][H\$Ht$UWAUH$@yH+HH3HHQH33D$`HD$hHt$p13HuHD$xx5HEq1L-B>HL$`LmHuHES5fuH
VL>H=E34H=HML43\1H65)5Ht$XH\$PHt$HHt$@|$8D$0LEE3I3ɉt$(t$ 4HȺH4H4HHH3cL$I[(Is0IA]_]H\$WHPHkH3HD$@HT$0H=43}4p4DT$0L$"H
L
2HL$ LH3t	H8fH=2u
	~H~	H8H
6\SHt%Ht H!AH=Hn!tH;!3H8H|$DLDAAu,DиD;rDED;D}HuBzAsFEtAIDEAuD;rDиqAkAA.qAn^AAP[AIDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDEEAiDAiDHE
AAHAAIDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDACEDEH@EtAIDEAuAiDAiDAEAH|$H\$DADAqADAEAEqi+DAiD+ںED+CD;rDD;rD=r;rH\$A_WH!H\$Ht$H|$DEHH5AEt#tAHH3DD3AuA !AHD3AHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CAEHAHDAD3HH D3AAD3D3CEAHADHAD3HD3AD3D3CAHADHAD3HD3AD3HArUEID3AHEAHADHAD3HD3AD3IuEtAHH3DD3AuH\$Ht$H|$AAHHXHhHpHx DѽD#EDЋAH5#DDAEt+t&AHHH3ADD3AuHZA AAHD3SAHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CEAHADHAD3HD3AD3D3CAEHAHDAD3HH D3AAD3D3CEAHADHAD3HD3AD3D3AHADHAD3HD3AD3HArYEIHAD3EAHADHAD3HD3AD3IuHEt&AHHH3ADD3AuH\$Ht$H|$ AAA#AA#Hl$A3tt3HuH(LLLL+A CIAIIuH(HHXHpHxUHhH0HVH3HE AED$  L HH |HT$ HMgHUHL$ YHT$ HMK@t
HM"t&HUHL$ &@tHL$ u3ދHM H30L$0I[IsI{ I]Hu3@SUVWATAUAVAWH8Hi(DqH9LALMXHu`Dm4]@DUDLII+DMhIHH+ЋE,A$E0HT$$HE8HD$LMlMLL$H4$$HT$ AsGAHAJAH#"uG@ʸA#AEAAD+EuIAEAt+D;sHAAʸ#DD+AsGAHAJA$H#ȋ4'@A$ʺH$#Ћ4@։$D+tD;s'HAAD;sHAAʸD+#A+D$;-+;$v
HT$LJEu*$+LA;D+IIAAulA+D;sG$A+LA;sXD+M+ICAuLJE;s;AE+IIAAuLA;sD+IIAAuML+Av7AKJAAIIA@AAAHA@AAuEtuAAH4$IAAv
AAIALL$YIH+ȊAHIA@AAA@AAwEt#AH4$IAAvAIA	LL$H4$I;sBM;s=HT$  t	E%H2Ht2HK2ID$ EAE+AE|$H+D+D+HGAI$I@Et$ID$ADUD#ÉE@H8A_A^A]A\_^][3HtaHQ(HtXBAAHA D@DALHBHB HB,B4HB@HHHHB`HBX3BDøH\$Hl$Ht$WH HHtZHy(HtQy3Ń0}t
|/*HW8Ht9_(tHI@V8Hg8HΉo_(H\$0Hl$8Ht$@H _H\$Ht$WH HMA81AXHuAHa Hy0uHa@H!HA0HA8H
!HAHDHK@HC8S0HHuF1HC(H`8HtHK@HS8Hc(H\$0Ht$8H _ELºEHtJLI(MtAy
Aa@AaD3Ã+EADEA wʸEQDAA#AA@͸H/Ah	AlHAXH7HA`HHXHhHpHx ATH HY(E3HL9c8u!K(DHN@V0HC8HuD9c,uK(Lc0{,+n{,HV;rHK8DH+#Dc4C,S+{4K4;GHK8H+D#+tHVHK8DI+#k4{4C4K,;ADĉC4C0;sljC03H\$0Hl$8Ht$@H|$HH A\ÉT$USVWATAUAVAWHHXE3ۋLHHy(HL9YL9u
D9YDg@wDD]HDENMVM.E~LUDMXLmD}EDM`C	;8t`vHXA_A^A]A\_^[]EAEIALmD;rDgAtH7`AtH7KHO HtAGt$DeAHUDeًOAE3ۉGEA"E@AEIALmD rHG HtD`Gt6ADeHUAEAADeۈEڋO&E3ۉGEA"EAEIALmD;rHO HtAĉAHG AHGt(DeAHUDeًOAE3ۉGASEAGHG HtLXG_HA;AG߅HG HLHMPH+WH;vs+qEAEIALmD;rHG DgHHtD`Gt$DeAHUDeًOAE3ۉGEA>DIIGtODIG)_HD+LE3LmD9_HD_HGtyEAMHG E(IHtHP HtOH;H(sD,GHEtA;rGtHUODE3ۉGD+HEELm
HG HtLX D_HG1EtjAMHG E(IHtHP0HtOH;H8sD,GHEtA;rGtHUODbE3ۉGD+HEEDmHHE]`E~IFEXAFHEIwD3Dg@9w,u?|A;^rI`SD9_u)9EtAEIALmD;rGtRAuIE333HUAGfDe؋OGE3AEDE`DMXLUHG D_HtH@GAAȸB+k;uzA$<tH2IF XAÃD9_(u7O(E333ɉGgAAԉGAFLAA	D'7;O(vHM2떺H'2IF HG HtLX0LmDE`DMXLU]PGtSt
g΃A+"EAEIALmD rAA;tH>12OHEAgDoHE<E;EGE;EGE8HUEIAH]DMXLUE+E+LD)oHLm]PDMXLUEAEIALmD rAAĺ#AAA#AEGAFL
D9_
E333eDE`DMXLUE3ۉGAFLASZQD9_t;θ#A+E)AEIALmDrAA΃GAătBttuHF$tMt*OJD9_"E/AEIALmD rE+EFDGEt4OAIH+D9_t4DMXLUE3ۉGASAFLAAEDM`A%AD9_AE;OtH3#7EAD9_D9_"EYAEIALmD rD;gH"EGHAIADMXLUG4;v	W,+++ЋGHHW8;v
	GHIH+ыA;AGD++I+DMXGHBAIuLUQAD9_HGtTVDE3ʃf@+щVDr%N@LL$0F@AIAN@VDsHN|HT$0!DGHHN|G)GDWH~|t#DOHDWDO3H\$8Ht$@H _3HtHI(Ht9
u9ADuøH\$Hl$Ht$WATAUH HLH=H4Hz(H'HB0HHz8HK@AAAHHu
3H9o8t&O(AEHK@S0HHuHK@HS8IHAXu	AHHd	L_XHHHL;rMu\L}EtA|A$E'LE3I_A~LEA̺pLEI@AHtD#HuPA-uA+uD#HEWAMA$CEu(A0tA
8;xt
;XtA&AAuA0u;xt;XuDcHM@3҃ADAEJAȃt	Ã0At.AD$A<w A;sA;r"u;vMuH@uMIE3\AD#HA@u@u<ƃtw	u)A;v$["@t@$AMtI@t߀}tHMMtM>@8}tHE3L\$@I[0Is@I{HIA_A^A]A\]H83EL9D$ Hu	H
3iH8H8d$ IELHHGH8H8=QELHD$ u	H
3H8H8IELHHD$ H8Ht7SH LH
3<uYHoYH [@SH HH
Hu 肂?H
HALE3H [H%H\$Ht$WH HHw|HHEH
MHu K?H
(L3uHHu,9GtH荂t
XXHgX3H\$0Ht$8H _H\$UVWATAVHH0HeH=1HHu@HukXXHHu_Dr=A1Ht HȻH+H;}HH	H;sHTHHH蛌HEHHtLHSHzʎHL轎L;hH;_J\ HIHEHH3LHHHEHA=E4HEHII+LIHHMHAtHMHHkH=
d$(He@Hd$ L3D3DuW*Ht$d$(Hd$ DL33tEdIc̺^HE@HtDL33Dd$(HD$ suHM@Ht>HM@>HM@DfD4AHM@HD+HAL33Dd$(HD$ %tHM@3BtHM@H2P(3H\$`H0A^A\_^]@SH Hٹ)3HbعH [H\$Ht$WH HH3ۋHuUE-ƑHHtU腐H\$0Ht$8H _H\$Ht$ WATAUAVAWHHkH3H$HHct$L3ۋHuOU(U"3DB0Hu%UT	;5eLLIL=bAMkXKBL AA#fKFt!uT	oJ!A;t ttKT8u fO7wfDwf__
H_(H_ H_u_KH\$(HD$HHD$ E3E33J!#L$HO_
_fDwKHT$`J!MTGDt$`t
$
fG9\$tu9\$xuH_ hHT$@HL$tYHT$PHL$@AD$\DT$ZDL$XDD$VT$RL$PL$0D$(DT$ 輕HG 9\$lu9\$puHG dHT$@HL$lHT$PHL$@fD$\DT$ZDL$XDD$VT$RL$PL$0D$(DT$ BHG9\$du9\$huHG \HT$@HL$dtiHT$PHL$@tUD$\DT$ZDL$XDD$VT$RL$PL$0D$(DT$ ДHG($GGfG_y(RR	AH$H3L$I[@IsHIA_A^A]A\_HHPHHL@LH SVWATH(H33HuQA3HtLd$`G@H讦t*t%HcHHLHkXIH
H
HLB8u%ttHcHHHkXIA8tP@u*HtME3HT$XH諛H׋'H^H(A\_^[LD$LL$ H(LL$H@H(LD$LL$ H(LL$HDH(HHPL@LH H(LHE3H(LD$LL$ H(LL$H$H(HHPL@LH H(LHE3H(H	@SH u;LHcȺ<HHu$PHˉHhHuv3HHH0HHt	H;E3HEHILIHIHkXLItItMuIH0Iu3H [H(;=t艦H
H(@SH HH
H;r>HtH;w2HH*H+HHHH?L謊kH [HK0H [H%@SH Hڃ}zkH [HJ0H [H%HaH;r5HH;w)qH+H*HHHH?LH0H%}
rވHJ0H%ffHL$L\$M3LT$L+MBeL%M;sfAMAM;uL$L\$HLD$LL$ USVWHHXHeH3IHDB(HMHu0M=\HtHtLM@HMH;HEBGE3H}؉]H}ڗHtMx	HEHU3HX_^[]LL$ H8HD$`HD$ H8ffLMt$H+t(HItuIHHHIv&I~LLIM3IMtIHItx$tuHItiHtbHItV$tSHItGHt@HIt4$t1HIt%tHIt$tHIu"-/HHL$ *3LEHHHHHH\$HHt$PH|$XH0A\A@@SH ILHHu.$AHIHHt3.H [HT$LD$LL$ USWHHPHeH3HHMDB(Hu;.(KHtLM0HME3HEEBH]H]xM؋x	HMHU3.HP_[]LD$LL$ H(LL$H8H(LMCMK H8IC E3ICH8LL$ H8HD$`HD$ H8LMK H8IC(ICIc_H8LH8IC0ICIC(IC<H8LMCMK H8IC E3ICH8LL$ H8HD$`HD$ H8HHHHPL@LH H(HPH(HHHHPL@LH H(HPH(HHPL@LH H(L@`H(HHPL@LH H(L@lH(@SH@HcHL$ yHD$ ~LD$ ?DH@DXA|$8tHD$0AH@[@SH@=HcuH3X%YHL$ 3HD$ ~LD$ A?DH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ >DH@DXA|$8tHD$0AH@[@SH@=HcuHKXVHL$ 3HD$ ~LD$ [>DH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ =DH@DXA|$8tHD$0AH@[@SH@=#HcuHgXVHL$ 3*HD$ ~LD$ w=DH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ =DH@DXA|$8tHD$0AH@[@SH@=?HcuHXVHL$ 3FHD$ ~LD$ <DH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ .<DH@DXA|$8tHD$0AH@[@SH@=WHcuHX%YHL$ 3\HD$ ~LD$ ;DH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ B;DH@DXA|$8tHD$0AH@[@SH@=oHcuHXVHL$ 3vHD$ ~LD$ :DH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ ^:DH@DXA|$8tHD$0AH@[@SH@=HcuHςXVHL$ 3HD$ ~LD$ 9DH@DXA|$8tHD$0AH@[@SH@HcHL$ -HD$ ~LD$ z9DH@DXA|$8tHD$0AH@[@SH@=HcuHX%YHL$ 3HD$ ~LD$ 8DH@DXA|$8tHD$0AH@[@SH@HcHL$ AHD$ ~LD$ W8DH@DXAW|$8tHD$0AH@[@SH@=HcuHX%WYHL$ 3HD$ ~LD$ W	8DH@DXAW|$8tHD$0AH@[@SH@HcHL$ UHD$ ~LD$ 7DH@DXA|$8tHD$0AH@[@SH@=˕HcuHX%YHL$ 3HD$ ~LD$ 7DH@DXA|$8tHD$0AH@[@SH@HcHL$ iHD$ ~LD$  6DH@DXA |$8tHD$0AH@[@SH@=HcuH'X VHL$ 3HD$ ~LD$  76DH@DXA |$8tHD$0AH@[3Ã@SH@HcHL$ qHD$ ~LD$ 5DH@DXA38L$8tHD$0Eu_uH@[@SH 3҅u_uH [@SH@HcHL$ HD$ ~LD$ 5DH@DXA38L$8tHD$0Eu_uH@[@SH 3҅u_uH [LH;t MtL+AHIADJuH;Hl$ WATAUH H\$@Ht$HLt$PN4MIHLffIIL;wDHHAՅHOHH;vLHH;t$HtH+fDHIȈDJuH+I;wLt$PHt$HH\$@Hl$XH A]A\_@UATAVHMILHu!HtHA^A\]MtMtHH$0H$8H$@L$LjL$LLE3ff3III+HHpHw&MLIINt NHHIHAԅ~6LHL;t+ML+fffffAHIADJuIIAԅ~3LIM;t(MM+ffAHIADJuIHAԅ~3LII;t(LM+ffAHIADJuIIfH;vHH;sHHAԅ~H;wHI;w
HHAԅ~H+H;v
HHAԅH;w6LHt!LL+AHIADJuH;uH{HH;s#H+H;vHHAԅtH;rfDH+I;v
HHAԅtIHH+I+H;|&L;sNt JII;"LI;sJ\ NIL;LL$H$@H$8H$0L$HA^A\]H\$Ht$WH HHHu
HjHu\HwCH
HHDL3LHHuo9tPHIFt+HvH7F3H\$0Ht$8H _qHTXH;H@SVWATAUH0I؋LLHHut3!3t3Ht҅tH\$xHC@H#qt*t%HcHHLDHkXIH
zH
zHLB8u%ttHcHHHkXIA8t[H3H|$ HtTΉt$htGKxHHH
HȉL$`uM;u3H|$ A$ILd$(
tA$HHH0A]A\_^[ffMtuH+LItB	H:uWItNtJHuJ	ffwHJ	H;uHII~vHLI3ItH3HHÄt't#HttHtttuH3@SH H
HtHHHtH [@SH ̹U̹T@SH })HHBHH2HBHHH [H;s-H\$WH HHHHtHH;rH\$0H _H\$WH 3HHH;suHHtHH;rH\$0H _H(HuHAHtH3H(H(HuHHtH3H(H\$WH H=.tH
#覾tսH&H
uZH
*HˇH=̇HHtHH;rH=ǮtH
9tE33AP3H\$0H _H\$Ht$DD$WATAUAVAWH@EDS="D%H
$>HHD$0HH
 HHD$ LHt$(LHD$8HH|$ H;rp	'H9uH;r_HH&HH
ƄHH
L;uL;tLH\$(HH\$0LHD$8HHD$ HH
GHH
4EtpQEu&WQASA"H\$pHt$xH@A_A^A]A\_E33fE3APX33DBK̺3D9@SH >x<E3AP@SH =su>G<H [MZf9 t3Hc
@ HHȁ9PEuf9Au3v	9H\$WHHL$00AMZH=fD9t31HcHǁ8PEuf9Hu3ۃv	9É$:u"=u=`;'u"=bu=5;躹Yy
`HHy
Zսy
	Gt21D$lT$pA
DEL3H$uD$ u$uH$HĠ_H(/H(RHL$HH
H؀HD$XE3HT$`HL$XCdHD$PH|$PtAHD$8HD$HHD$0HD$@HD$(HHD$ LL$PLD$XHT$`3c"H$HdH$HHHJH~H$H~	~H_HD$hH_HD$p€~3H
=~u
}	H^HĈH
}H\$Ht$UWATH$HHH_H3HAكtEd$pHL$t3A覩L\$pHEHML\$HHD$P	LHT$@IE3bHt7Hd$8HT$@HL$`HL$0HL$XLHL$(HMMHL$ 3\bHHHHHt$p|$tHEi3ɋWHL$HDuut`HH3IL$I[(Is0IA\_]H\$WH HH
~HHHHH\$0H _H
H%~H(AAHP|HH(H%~H8HD$`HD$ H\$Hl$Ht$WH0HH
~AIH'~DLHHHt!LT$`LT$ H\$@Hl$HHt$PH0_HD$`HD$ JH8Hd$ E3E333wH8H8Hd$ E3E333WHd$ E3E333H8HD$`HD$ -H8@SH +H [@SH H [@SH H [HSVWATAUAVAWHPE3EADpDpDpAN@KLH$
H$M
H$h
D5AD=_D=_H
ȿHHD$@HD80H
wHt$HHH
XHt~HDHHeBH6HHuDLHPH
AhLt$ E3E333RH
HtL5H
')|!
k<$LfD956tk<ȉ$fD95rt#xtDŽ$+k<$D$D$H$HD$8Lt$0?t$(I$HD$ ELy~3ҋk{tD9$u
I$Dp?I$D0H$HD$8Lt$0t$(ID$HD$ ELz~3ҋ{tD9$uID$Dp?ID$D0$Z$<$6GD~ELǍV@I$(I?-uDnHH聻DEiD$0@9<+:|	@:?:udHHCkR3H(HHXHhHpHx ATH IHHHt?Ht?HtHt2EtAu'IcL%vRI6HHHu35HtH;v"MHH3H\$0Hl$8Ht$@H|$HH A\HyQHuQHeQHQL
Q3ID@;
t+IЃ-rAw
ÁDAFHADH(Hu	HSHH(H(Hu	HRHH(@SH Hu	HRHLRHtLP;AH [@SH cHuRHu	HjRH3H [@SH HHu
!CHu	H/RH3H [@SH HuHu	HQH3H [@SH HHu
CHu	HQH3H [H\$Ht$WH 3HHHugS\A$HtDA@W}.ʸy-AЋFiyD3D;|%D+D;|D+D;|D+SE.L
w]AAH]SD[iҀD…LDȺIIHD9|ʸE.HcʉSE+D[/c L$Iиųk+AKAиSiDAAЉSk聅Hd;PAELl;XHd$ E3E333@SUVWATAUAVHH7,H3H$IHt Ht
3HcHHDH"3DfHA8LAAxC6Ax_+HtHHHLL+x8;oAL%.I$MHuI$L;tHfIAL;~HHHxHHu
};
A4HL$0LLź藍uaLD$0AHψD0HtH݀;tHÀ;HhH$H3{HA^A]A\_^][Hd$ E3E333!t$(H!t$ HT$0E3AHHt3HoHt-HUHL$0輍tLD$0HHuE3H ~EQD3MHHXHhHpHx ATH Hw+Ht&AAAL$iHHu(3H\$0Hl$8Ht$@H|$HH A\IԹ`,HHu
H褂IԹ 
HCHu
H脂H;Ht%H7H;tHA`t'HHLƋHtHHSHt%HK'HHH3HCD HCD HH\$Ht$H|$ ATAUAVH0LD3v3eHHD$``HH'uHHtH;tHA`s'HMAHHHD$ HMt)HT3IX
MAAẺ
LAHHHuLD%2uCHH
7L
7I(H:I@H6;A9;KHIHHH\$PHt$XH|$hH0A^A]A\H(E33D$0HHLHt)H<sH
KLD$0A3\HH(H(H
KGH%KH(HKL)3I;
tHr3HHIDH\$Hl$Ht$ WATAUHPHb&H3H$@3HHNuNu
=)\H-KALhHA3ɅL-KAf5MInDA|$u*LItE3E333Ht$ I#HHHtH(H5?Hu H>HtH(H5>HHtHM+HILl$pMcHtE=MHI?3ɅuHfB94hfB9hHHHuH5u>H+HE3L9mHcHLxEtfL9ltHLHHHDHL9luHcHH;H
>A%Ht{rH5=H+HsLdM.\EyߍG;tLcHL;^HHHHcL$LlM.Hy=D9l$xtuIHzHHtUIMHHuQHD$pHHGfD*HEIE>u*HwEtIwM.E3E333Ll$ IqwM.HHfuH+HHH\$Ht$WH H~<LcHHHHt4ILHuH<=t4<t.HHHuH9<H+HHt$8H\$0H _H+<HH\$Ht$WH H3HHt[H9tHH8uAHcHHHuH	hHHtH+HHH;HuH'HH\$0Ht$8H _H\$T$UVWATAUAVAWH0E3LAHuL!M=IHHD$pHL;D8hH5
;EAH;5;utHAHuIYHL9.uHcHHHuH	hHEHtH+HHHH/HuL/H|$pl$xH5:Ht8L9-:t/Ftj	H$H0A_A^A]A\_^]Et3߹H*:HtL(L9-+:uH:HtL(H59HHtHHA+LcHt?HMI0uHA|=A8\HHHuH59H+HE3L9mHcHL,tEtfL9ltHLHHHDHL9luHcHH;H
.9A_Ht{rH59H+HsLdM.\EyߍG;LcHL;pHHZHcL$LlM.H8D9l$xttIlHHHHtVINMHHP{uRHHI+HT$pD*HEIE*:u*HrEtIrM.E3E333Ll$ IrM.@SH Ht
HtMuDs_H [LM+ACItHuHu:"3@SH R9;gDG؋H [ËVD
PDHHXHhHpHx ATH =-D3HAHhrHHu(t$8=DDD;AAGA;uHl$8Ht$@H|$HHH\$0H A\HHXHhHpHx ATH 3HHAE3HHiHHu*9Cv"]8DD;sCAAGA;uHl$8Ht$@H|$HHH\$0H A\HHXHhHpHx ATH 3HHAHH謭HHu/Ht*9Cv"7DD;BAAGA;uHl$8Ht$@H|$HHH\$0H A\H\$Hl$Ht$WATAUH 3IHALLHIHHu/Ht*9xBv"J7DD;`BAAGA;uHl$HHt$PHH\$@H A]A\_ffHHHtfHt_uI~IHMHLHI3I#tHPtQtGHt9t/Ht!tt
uHDHDHDHDHDHDHDHD3Ht9tHHH;rH\$Ht$H|$UHH@HًHMIk3Hu8@8utHE3H\$PHt$XH|$`H@]HU9ruH_@8utHMft3DtH@83t;u
HC;tH;l@8utHEHfE3LI[IkIs ISWATAUAVAWH@MyM1AIy8M+MLHfIcqHIKMCH;7HH\CL;CL;{;tHL$0IIЅ~t}csmu(H=]tH
]mtH]KAIIrYID$@SLcMHD$(ID$(ILIHD$ 3sYH;793MA 3E3M+Ǩ t;39v5HOAL;rL;vH;sHLulDIcqHH;7sUHHHߋCL;r9CL;s1EtD;+t1t;kt(;uHT$xFAD$HDCMAH;7rL\$@I[0Ik@IsHIA_A^A]A\_H\$Ht$H|$ATH L%"33Iu&HcƺHH:>HHU2t&H$|ɸH\$0Ht$8H|$@H A\HcHI$3H\$Hl$Ht$WH $H$"H+Ht{tH1HckH#HHuH!HKHt;u1HHuH\$0Hl$8Ht$@H _HcH!HHH%2H(H3]1H(H\$Ht$H|$AUH HcپH=6uN,ʪHHL-9!I|ty({HHub3X
fHI|u-0uH?j&3
I\$jH
\!1H\$0Ht$8H|$@H A]H\$WH HcH= HH<uuH轭HH\$0H _H%H1HHXHhHpHx ATH MQ8HMAHIHHII\L:_DDUAA#AfDDEtLMHHH\$0Hl$8Ht$@H|$HH A\H\$Hl$Ht$WH Hڅxg;
oWs_HcH-wWHHHkXHDH<u;=u%ttu-HDH3	 H\$0Hl$8Ht$@H _H\$Hl$WH xq;
VsiHcH-VHHHkXHDDtEH<t>=u'ttu3-HDH3	 H\$0Hl$8H _H(u 	Mx1;
Vs)HcH
VHƒHHkXHDtH| T	AHH(HHXHpHxL` AVH HcLIL5UHkXK4|3u4O	|3uHL3k-#D3
tKHL\.H\$0Ht$8H|$@Ld$HH A^HcH
"UHƒHHkXHHLH%.H\$Ht$H|$ATAUAVH@HDE3^suI3HT|$$@LcJHH\$0JHH;C{u<
{u!HKN,uDhDl$(C
EudHK;-CtHK3-HHEu?CH3LTK+H.袋.HLIIH?LDDd$ HXHHSD;XJHD$0HtsHcLSIЃmS IHH;s@H0@	
`HXHD$0|$ HcHHHkXID[DD|$ }AH\$`Ht$hH|$pH@A^A]A\HHXHpHx ATH0HE3D`AAD$ Esˀy+u+Su@uHc|$HuD H֋HHHLIRHkXIȈ\IȀd8IȀd8D$ H\$@Ht$PH|$XH0A\@USVWATAUAVAWHHxHe
H3HE3McHc}}}F\LPFDA:LcmhA;,LcupA;DWE;H
AQDLA+A;}b%}	A+ƒA…uAkd;u#lAiҐ;AG$%}	A+ƒA…uAkd;ulAiҐ;u~E謶HMKHMjHM艺+AQDCADe]D}DmDuDAAADAAD+ʙALHcHFHcHimHIcHHcEHRIIE3҅D$@A tfD$\YA@A
T$HDt	MI:ArIA tLt$pA@tMFEFA@tMcFEFLt$pA@t
MyIADu
ArEEyAAE;EODt$`IHH#ʉL$HAAυMt 3IIcHLB09~AƈHLt$pH+HÉD$DEt	;0HD$D0uAgu=A5E;EOA~%A]HcEHEHtH؋AIH
IAHcHEHMDHL$0L$xLƉL$(HMHD|$ AtEuH
tHUHAguuH
L~HUHЀ;-uAHHE3҉D$DD9T$\FA@t1AsD$L-AtD$L+|$HAtD$L |$HDd$THt$hD+d$DD+AuLL$@LAԱ 	LL$@HL$LLƋIAtAuLL$@LAԱ0|$D39D$Pti~eHDHHMAHE3҅u+Ut$LD$hLL$@HE3҅uHt$h%Ht$hADD$@LL$@LƋHE3DD$@Ex AtLL$@LAԱ +E3DD$@HEHtH*SDD$@E3LUH}T$XAL
fD'EYD8UtHMAHH3JH$ HA_A^A]A\_^]AIt7Aht(Alt
AwuA뗀?lu
HAAA yA<6u4uHAZ<3u2uHABIEDCAD|HEA*uAID$TfAD$TAčDHЉD$TFA tAA#t1A+t"A-tA0$AAA	AADT$xDT$\DT$TDT$HEDDT$P迪謚38EH(Hu蚪臚AH(HHXHpHx HPATAUAVH MMHL33HuD13MtHA[G@Hbt*t%HcHHL>HkXIH
H
HL^>B8u%ttHcHHHkXIA8t蚩臙u(H(LL$`MIHA֋H׋H[H\$@Ht$PH|$XH A^A]A\H8LL$ MLHH
H8H8LL$ MLHH
zH8H8LL$ MLHH
#VH8H8LD$ LHH
E32H8H8LD$ LHH
E3H8H8LD$ LHH
E3H8H\$Ht$WH03Oc_\$ ;1O}eHcH
?H<tPHAt`tlj|$$|1H>HH0zH
>HML>I$돹H\$@Ht$HH0_H\$Ht$WH A3H$<u?At69+y~-HSDNj0;uCyCK HKcHt$8HH\$0H _@SH HHu
H [4gt C@tH]^3H [H\$Ht$H|$ATAUAWH0D33N3A\$ ;MLcH=J<thJBt^XHc=JAt3Au6A;t#Ɖt$$EuAtA;AD|$(H=J@XpADH\$PHt$XH|$`H0A_A]A\H\$HL$WH HHuWHHWH\$8H _̹HHXHhHp HWH HHKHcu肥	K 4@t
f"3t{HCHKC{Cu/7UH0H;t)UH`H;uQuH譿C+HS+kHBHC$ȉC~Dŋ&.W K?t#tHHH49HHkXHH
|A t3ҋDBEHHKD$0HT$0D-;D$0H\$8Hl$@Ht$HH _H\$Ht$WH IIHH;
udM9u=HHHu3KHD$PHLHtmE3tfHe@?lHuE3E|$kt$\E3߃E|$<t>D$Lt$\D9D$`tD+t6H\$hD$4HD$	AcAd*	RAg~vAitXAn<Dt$4AƄuDt$LHMEHEHDt$4Ht$pLd$`ADl$9I3Ht$pRAd-$T$@ Iك-u
HD$xH@8+u(Ll$`Dd$HDt$4ID+DQE3ɋD$<Dd$HLl$`Dt$4D9L$P@EDb3^AĹD+tSHD$xL$XLM@<HHELD$xHUHHD$ $IAȋD$D$Xt$\D9L$PtD+t6H\$`D$4H&D$%~nA;HT$`辛E~fD	D	螀A;tHT$`芛ArE3E@t	fD#qD#iA;t
IԋIA;IIsE>Au'
pD8etHMD$h\$h38MtHEHpH3H$HĀA_A^A]A\_^]H\$WH HcHtYH+u	@u
;u@`tH贽H;t訽HWu
53ۋܼLHHAHHMkXBDtN3H\$0H _H\$L$VWATH Hcكu~ ~	xe;As]HHHL%BHkXIL8t7RID8tv~	ν}~ U~	BnH\$PH A\_^@SH AHt"AtHI.$c3HHCCH [H\$ UVWATAUAVAWH$0"0H+HH3H 3EL!|$DHcEu3Hu}!8}mLLHIAJLd$PMkXAt8L|$`@@@t@u	AШtAD t
3ҋDBgtqHJAD耎3HT$\HH9YJI?}t	@p,!|$XI݉D$\EM@3
D$LH"JA|Pt ADLL$aAD$`AdPHT$`It4IH+IHHL$@AHHAHHL$@Hd$8Hd$0L$\HD$`LD$@A3D$(HHD$ DNHL$PHd$ HEHLL$XHT$`IE"A+|$DD9d$X|$LLd$PHd$ HD$`
JLL$XHT$`IA|$XD$Dz@t@uE3f
fD$@AHDd$LDd$L@t@u:L$@Θf;D$@ugEt!A
AfDd$@諘f;D$@uDD$DLd$PA+A;s&H!JADLJADP\$LR\$LHJAD3M@ES
D|$DH 3AA+A;s'A$I<
uAHHHHHrH!\$ H DD+HD$PH
[HD|$DL|$`ILL$HH /|$HH H+HcD$HH;Aĺ
A+A;F@EH
D|$DH 3AA+A;s2A$If
ufAHHHfHHrH!\$ H DD+HD$PH
y
HD|$DL|$`ILL$HH M|$HH H+HcD$HH;*Aĺ
A+A;;EpA
HL$p3AA+A;s/A$If
ufDHHHfHHrHd$8Hd$0HD$p+LD$pD$(U
+3DH HD$ %D3HD$PHd$ HcH
 EH
XHHD$`LL$HHD+tt$HD;D;AA
A+A;L|$`t\uK]w	rw1IH!|$ LL$HEI{|$H3뤋PwxHD$PH
HAD@tA}2vv =+|$DH H3H$H0A_A^A]A\_^]H\$L$VWATAUAVH ALHcuv pv	xs;=
skHLIL5
HkXKLtEKDtDIԋ
v	v Z	v u	eH\$XH A^A]A\_^@SH@HL$ HD$ DH@BY%|$8tHL$0H@[@SH@HL$ 3HD$ DH@BY%|$8tHL$0H@[̺骓̺鞓̺钓̺醓̺z̺n̺b̺V̺J̺>̺2̺&̺̺̺̺̺W̺Wޒ̺Ғ̺ƒ̺ 麒̺ 鮒3f;@SH 艒3҅uf_uH [@SH ]3҅uf_uH [@SH 13҅uf_uH [@SH 3҅uf_uH [LEIA@wA 
HAw EtD;tD+AH\$Ht$H|$UHH@HHHMI?Hu(rb}tHEkHtHExuHHT}tKHM>H+>HU虑HU苑HDžt;t+؀}tHMH\$PHt$XH|$`H@]H(=]u-Hu=r*bH(HtH(E3H(H\$Hl$VWATAUAWH0-IE3E3E3ۀ: EyEHLuI߀; t;at/;rt#;wtqa373A	IA׊A@ȃSytj tGt>t'
tuEE׃@@@Ez@utmEu`E׃ `TtMt:t)tu4A7Eu*E)EuEAus3Iߊ
EI߀; tH
]AHHI߀; t;=I߀; tHd]AHBu
HMHM]AHu
H*H:]AHHI߀; t;HL$hEDID$ 袙D=!FD$hH&HfHf(FnHH\$`Hl$pH0A_A]A\_^H\$Ht$WH03ۍKS3|$ ;="HcHH<tfH@uU@uLGwO$HHb LI@tHЋ H|yX賢HHcHvHHtUH0uH
SHLCI$$H5HH0L IcHtccHcH#Hc(KHH\$@Ht$HH0_ffHM3M3Hd$ LD$("HfDHL$HT$DD$I ffHHXHhHpWHPH`H3IHDB(HHIHuJm7]RHtHL$ LLHD$(D$8BH\$0H\$ L$(x
HL$ HT$ 36H\$`Hl$hHt$pHP_ME3=HHXHhHpWHPH`H3IHDB(HHI4Huls\,Hd$0Hd$ HL$ LLHD$(D$8BH\$`Hl$hHt$pHP_LHH
E3[MLHH
CLHH
?sE3+MLHH
$sH\$Ht$H|$UATAUHHP3MLHHMDC(3IH]<Huk{[vMtHtLMHLE@L;AHGHMEBHuHuЉEAՋHt3x!MxHEЈHU3kt9]B\&ÍCL\$PI[ Is(I{0IA]A\]H8LL$(Hd$ MLHH
HH8H8HD$`HD$(LL$ MLHH
HH8@SH0HMtGHtBHt=HD$`HD$(LL$ MLHH
adpyu 3j"&jZH0[H8LL$ E3H8HHXHhHpHx ATH0IIHHMMuHuH3HHI;vMiLFH
cHD$hLHD$(HD$`HHD$ ul^i8"Pi~GiH
XcLD HD$hLHD$(HD$`HHD$ GDuHui8"u3hD )y(uh"hXH\$@Hl$HHt$PH|$XH0A\H8HD$`HD$(Hd$ H8H8LL$(Hd$ MLHH
oHH8H8HD$`HD$(LL$ MLHH
o`HH8H\$Ht$WH HHuhWA@t AAuxHAHHDG$HW\GGu_Hڼt=u5H
uacHqAσtl	t?tt^H\$ H
$HHH^HvH
HHt`H6HNH
HHt8HH&H
~HHtHH_3褝EuH-t$t
t~~bqRHH\$@Ht$HH|$PH0A\H\$Ht$WATAUAVAWH03|$`3уtbtMtXtSt.tt5	bQ@L%H
L%H
|L%H
lrHHurHHLcP9YtHIHHH;rIHHH;s9Yt3LaM,$ L%H
	|$`*LIu3Mu
AMK̅t3<tttL|$(,LL|$(HuDdžDt$`u9
%OщL$ O;}*HcHHHd‰T$ 
NpI$t3肛;u
AA;tt	L;	DH\$hHt$pH0A_A^A]A\_H
H\$Hl$Ht$WH HH
HHu_OeHu~H
@MHHtHMHjHHu+_HI_Op5_JHHZoH7H;t	HyHׅuB_7_3H\$0Hl$8Ht$@H _@SUVWATAUAVHHH3H$H$0AEL
LL$@DAH|$@3D$ GDu\zux!l$ E3DAI Lct\UIHHtILDAIνDl$ DtIcHؒHHHu1tHIH$H3FHA^A]A\_^][AELHLc
utH3Hd$ E3E333M̽;uTH#E3E3AHct'Hϋ1HHtDLAuHH#B:!T$0LD$0DAD$0SH
H\$Hl$Ht$WATAUH LH
H
HHH;HH+LcIHȔHI;sOH;HBHH;r
HđHuHV H;rGH讑Ht:HHH<H=IHOHHI3H\$@Hl$HHt$PH A]A\_@SH J轐HHQHHHuCH#3H [H\$Ht$H|$ATAUAVH L/BH
LH
{HI;HI+LoII艓HI;sUH;HBHH;rI腐3Hu3HV H;rIIiHt9uǃ*9uǃ9ǺD‰AЉ
LIIAH3H\$0Hl$8Ht$@H _øcsm;u 3H\$WH 39=u+cH|H]HHD؀; w	;t3t);"u	3tHH< w	HÊuHH\$0H _H\$Hl$Ht$WH0=%ubH3Hu<=tHjH\uGHc觊HHmHtH;tPH,;=pt.HcHlHHtsLHH:uKHHcH؀;uHLHH%<H'>3H\$@Hl$HHt$PH0_Hd$ E3E333DH
mH%H
HHXHhHpHx ATAUAVH Ll$`MIAeLHAHtLI3;"u3@"HË9AEHtH3HËtAEHtHH@tu@ t@	uHt	GH3;; t;	uH;MtI<$IA3H;\t;"u6utHC8"uH33҅Ht\HAEutOu< tG<	tCt78HttHÈHAEHtHAEAEHYHtHAEMtI$$AH\$@Hl$HHt$PH|$XH A^A]A\H\$Ht$ WH0="u_H=4A3H&ԾHH=Ht;uHHD$HLL$@E33HHD$ Hct$@HH;s\HcL$HHsQHH;rHH݆HHt8LHD$HLL$@HHHD$ gD\$@H=A3D۽H\$PHt$XH0_HHXHhHpHx ATH@E3HHHfD9 tHfD9#uHfD9#uLd$8H+Ld$0HL3DK3Dd$(Ld$ :HctQHHHtALd$8Ld$0DKL33ɉl$(HD$ uHIHHH3H\$PHl$XHt$`H|$hH@A\H\$WH HHd$0H2-+H;tHHtvHL$0H\$0dDI3DI3THL$8DI3KL\$8L3HL#H3-+L;LDLILH\$@H _̃%I3DB
%L3DB
F3DB
	L3DB
*3DB
L3DB
@SH 3MMuHuHu3-HtHtMuMu;P'@H [LLIuM+ACI„t*Iu#L+CAIÄt
ItIuMuAMyIu
\A@P뚈O"ffH+LtB	:uVHtWHuIJ	ffwHJ	H;uI~LHHI3ItHH3ffft't#HttHtttu3HHH\$Ht$WH =H+HtmHuH9*t_@uVHHtJHtEH΄HHHt2辄H;vH<9=uLH-@tHHHD83H\$0Ht$8H _H\$Hl$Ht$WH0IHHHu(!N
>H\$@Hl$HHt$PH0_H!HtHuHuHtIHHu3HHHEHtH;v"LHHtHd$ E3E333IAI)IAIH0HtD	u?H8H`HHHPHPH@H04HD$X0H0IH@IH8HHIHPD$P$HL$XIIIITH0HtH5H0H@Hi:H8HHH;HP3H$H3eL$I[8Ik@IsHIA_A^A]A\_H(WHH;
tOulUHȋH(HuHH(CWHH;
=tuUHȋAH(H(WHH;
tǝuTHȋAH(H(VHH;
͡tuTHHAH(˅tȀ9t	Hu+ЍB@UATAUAVAWHPHl$@H]@HuHH}PHH3HE]`3MEU~*DIA@88tHEuAA+;ÍX|DexEuHD`DMẢ|$(H|$ 0Lcu3I~^3HBIHrOKL-Hw*HAH;wIHbH+H|$@HtHHt
HHtDMƺADl$(H|$ LDu!t$(H!t$ AELAįHc"AEt7Mp;HEhL$(ELAAHD$ |~g3HBHHrXHL6I;w5HAH;w
HHfH+H\$@HHHtH3HtnELAAΉt$(H\$ 3ɅtHMHDAHD$ =EM?HMHDAHD$ EM@HMHDAHD$ EMAHMH DAHD$ EMBHMH(DAHD$ EM'HMH0DAHD$ EM(HMH8DAHD$ wH@HD$ EMHMEAVEMHMHHEAHD$ 5HMAHPEAHD$ HMA	H\E3HD$ EM0HMEiHpDADXHD$ EM0HxHMDAHD$ EM1HMHDAHD$ EM2HMHDAHD$ aEM3HMHDAHD$ @EM4HMHDAHD$ HhEM5HMDAHD$ EM(HMHDAHD$ EM)HMHDAHD$ EM*HMHDAHD$ EM+HMHDAHD$ zEM,HMHDAHD$ YEM-HMHDAHD$ 8EM.HMHDAHD$ EMBHMHDAHD$ EMCHMHDAHD$ HHD$ EMDHMDAEMEHMHDAHD$ EMFHMHDAHD$ rEMGHMHDAHD$ QEMHHMHDAHD$ 0EMIHMHDAHD$ EMJHMHDAHD$ EMKHMH DAHD$ EMLHMH(DAHD$ EMMHMH0DAHD$ EM6H8HD$ HMDAjEM7HMH@DAHD$ IEM8HMHHDAHD$ (EM9HMHPDAHD$ EM:HMHXDAHD$ EM;HMH`DAHD$ EMHMHxDAHD$ bEM?HMHDAHD$ AEM@DHHD$ HMA EMAHMHDAHD$ EM&HMHDAHD$ EM'HMHDAHD$ EMHMHEAHD$ EMHMHEAHD$ {HMAHEAHD$ XH\$`Ht$hH|$pH@A]A\]HSH HHIRHKIHK@HK 7HK(.HK0%HHK@HKHHKPHKXHK`HKhHK8HKpHKxHHHHHHHxHlH`HTHHHH [HHXHhHpWATAUAVAWH@3HHHHX9Yu9YuDDH-AAVcHHuAH(HLLbLHu
Hȉ9^HbLH~>HL$0AADHl$ .HMHL$ HL$0ADAԋ
L}HL$0ADAL|$ AHEXHL$0AQDHD$ AHE`HL$0AQDHD$ tH(AHII3<0|<9
,0I8uQ<;uLA@AIuHLHEHHEHHEHЍHEXH͍HE`E&MtEeHHtHHt	uHH(LLH(3L\$@I[0Ik8Is@IA_A^A]A\_E3HD8	t<0|<9,0HD8
u<;uLA@AIuHSH HHIH;
tqHK H;
t_HK(H;
tMHK0H;
t;HK8H;
t)HK@H;
~tHKHH;
ttHKhH;
tHKpH;
xtHKxH;
ntHH;
atHH;
TtHH;
GtH [H\$Ht$H|$UATAUAVAWHH@3HHMDH]9Yu9YuDL%eAA_LHu
)_LHu
I؉9^=H^LHu
IIщ~8AID$HMAQDHD$ IL$ AHL$ AQHMDNj]IL$(AHL$ AQHMD;AHMID$0AQDHD$ AM|$8HMAQDL|$ APID$@HMAQDHD$ AQID$HHMAQDHD$ HMAID$PD3HD$ HMAID$QD3HD$ sHMATID$RD3HD$ SID$SHMAUD3HD$ 3HMID$TAVD3HD$ HMAWID$UD3HD$ HMARID$VD3HD$ HMASID$WD3HD$ AHMID$hAQDHD$ AHMID$pAQDHD$ oAHMID$xAQDHD$ MAHMI$AQDHD$ (APHMI$AQDHD$ AQI$HMAQDHD$ t InIIII3<0|<9
,0H8u)<;uLA@AIuH·IM3H(HI$H(HHIL$H(HHIL$H(HHXIL$XH(HH`IL$`AMtAEH HtHHt	uH(H	L LL(3L\$@I[0Is8I{@IA_A^A]A\]H(38H
4H9t~u6HH(HUH(7HH;
t~u5HH@H(3@SH E3LHt
HtMuD&	H [D8tHHuHuEI+ABItHuHuE%"3H8HrH3HD$ E3LL$LL$LL$LL$LDIBIAu$AIEAIBtIcHL$ H3ZH8HHXHhHpHx ATAUAVH 3MLx?t=IM>+HcLMK舲uKLIM
y}u;~Hl$HHt$PH|$XËH\$@H A^A]A\@SH IHC$C H [H\$WH HHHtS9tNH&t>H&Hu!O$DHLD$0 lt-D$09HB/O$LD$0A ?u3D$0u)H\$8H _E3Hz%A@f;
tDHA
r3̊LE3'BI<w
B<wAEFLЄuA3ҊHCtCtCucH [H3ҊHA|Z~aw@SH HH	#S3H‰St*SH
CucH [H3ҊHA|Z~awH\$Hl$VWATH0MHH-H@HuKHF@H3HCHt8tLCH
HcHti8tdHCHt8t
HsH{H
$Lú@trHCHt8t
H1ZHPHKHt49t/Q3ɺHKH
BCucCC C${HHHH#tZ?tUHHtBHHu%K$DHLD$P [;|$P;H-/K$LD$PA *
|$PuK {HtC fEC$f}fEMf9Eu.L@IMt1Hd$ E3E333e	̋K A@Mĺt=K$MD$@A@t A
I$EAZ3H\$XHl$`H0A\_^ffH+Ir"tf:
u,HIuMIuMt:
uHIuH3ÐIt7HH;
u[HAH;D
uLHAH;D
u=HAH;D
u.H IuIMItHH;
uHIuIHHHHHHH;H8HeH3HD$ E3LL$L\$L\$L\$L!DIBIAuAAHuIEEu3HL$ H3iH8I@SUVWATAUAVHPH6eH3HD$HALL'3H9HH
OAHHH&HHzHHHHdH˅HHHDHH|HHr$HLHiHt"H5HHcH<H3H*L+H;tbL;t]HH
HЄLHt@8uH\$H|$DYAًLAp"ApE3ҺAst	AASuAst	AASu…iAdtfD:t;Aot5Aut/Axt)AXt#AdtD:tAotAutAxtAXukAdt D:tAotAutAxt	AAXuAdt D:tAotAutAxt	AXtA;t3MAI3r3 uA99,;uAAAA;tAҋ
E3E:AAH\$H|$@SH B@ItHzuA%Jx
HHSu	H [̅~LH\$Hl$Ht$WH II@LH@?tH\$0Hl$8Ht$@H _H\$Hl$Ht$WH A@@IIHtIxuA7~3MLHHŃ?u8*uLHֱ?H\$0Hl$8Ht$@H _HHH@H\$UVWATAUAVAWH$H`HEH3HX3HHMLHUHL$`IM}D|$P|$D}蓚AAH}Hu+B/@8|$xtHL$pAOC@HbMHVA;t(t#LcL
cIAHMkXM 
LL
@A@8u)A;ttHcHƒHHkXI B8t,@8|$x]HD$pLMtH]D߉D$L}Aum|$TME$$McËH}ED|$@}|$HD}ȉuLEEAMLM[AD$u
AI%Ac"IcH@M	HED\$TE3H]DD]A A@A;MvAc
IcH@HD9-DD	e~g~inopslu`x:'Ac/
IcH@MuHD9HHAt0HD]HD]QH
A+fD9tHuH+HHHD)QHA+D8tIÅu+A|$HEAEAQQD$X0T$PD$YAEyuDku	I>I%Ac:	IcH@MHH8uE3D$LA tfD$DA@A
T$PAsHuMIAcIcH@MueHD9u;KAsLtAc~IcH@Mu"HD9uHLA A@tQu
MIAcIcH@MuHD9AHLu
EIAcIcH@MtHDlA@t4u	McIYAcIcH@MtHLc2u	EI%AcYIcH@M@HDA@t
MyIAAr
ArEyA	A;OD}IHH#ʉL$PA+Mt 3IIcHLB09~ALjI+D}H|$H+IۉD$TDt	;0I+D\$T0uEEĺHNE31LEH]y
D$HIu
AguAD\$H:;O|$H~)]Hc;"E3HEHtH؋D$HD9Uu
IIHE AcIcH@HHHMH
nMAHc[HL$`DHL$0MLƉL$(L$HHӉL$ HMAt|$HuH
8Mb[HT$`HAgu E3uH
M>[HT$`HE3;-uAHHr#D$TAtD$X+|$PAtD$X |$PDeHuD+d$TD+AuLL$LLAԱ NLL$LHL$XLƋAtAuLL$LLAԱ0|$T39Et^~ZHDHPHMAHu&UЅtLELL$LHPuHuHuD$LLL$LLƋHD$LxAtLL$LLAԱ E3HMHt	Le؋|$H|AItJAht;AltAwAA9lDT$@u
MAAA AD<6uAy4uID<3uAy2uIAIDHUA
I耐HMLELIAA+LMMHH@H8DT$@|$H|$HDƄ*DAč|HЉ|$HADT$HA*uAIHUA
ȈHMLELIAA+LMMu\#9$AdDT$@A;DOHE3H@DT$@HD9 7EA*AHgHH@HDT$@MAىMEAčLHЉMA tEA#t5A+t'A-tDT$@A0AAEAADUDT$DDUDT$PE|$HDUpMuA;tfM;ut\HT$`ADUNst(HULD$LAHED HHEEHULD$LAM|$HLMDT$@E!uD$LUEA3t	A;D]uNEuILMcEx>HJtttt
t	tu]L2IIHM;~3D$LAD]A}LLeA|$xtHD$p*@8|$x@8|$xtHL$pHXH3H$H`A_A^A]A\_^]H\$L$VWATH Hcu	;={s}HHHL%{HkXILtW%IDt+s%H
Su
T3ۅt%	V&	H\$PH A\_^H\$WH HcAHT$8$Hu	HWT$8LD$EAIcEHTE+bDE;D}AHcDeXHAHHkXIƀd8Dd8HcHƒHHkXIƋƀd8D8@8}u @tHcHHHkXIƀL A#;AHMEEDEHMPH|$0D$(ALMD$ A=EHu59ELcIAHMkXIBdsHcHʃHHkXIH
.E3E333H|$ *HĉPL@LH SWHHH`E3HAEuHD$pHD@DD$(D$ @DLHT$0HL$4D$8|$4t9t(Hc\$0HHHHkHkXH€d\$0\$0t#8oHH_[H\$WH@d$03H|$pHu3Htك|$xtAtDL$(DD$ DLHHL$0؉D$4|$0t,t!HcHHHkHkXH€drjH\$PH@_LECMK SH@d$(MKIC MKD\$0L$0EˋH@[H8ADL$`ELD$(HL$ DAIH8HHXHpHxL` UHH@HHHMIIwE3HuD8etHE3|HMD9auLHHNHu+M:D8etHE/HtAHHDL
tWHuADLlD8'uACfHff;Qrf;QwfQ$f;Qrf;QwfQDtDHAELtPHuA_HD8&uAQfAHfDAfD;Arf;AwfA+f;Ar%f;AwfAADt
Af;ufHD8etHMH\$PHt$XH|$`Ld$hH@]E3HHXHpHxL` UHH@E3IHHMu3HMIuL]E9cuLHHHu+n[D8etHEHtAHHFDt/HuAFDu^JD8'uA
ffHHFDt%HuAHD8&uA
ffHf;u$ftHuD8eHED8etHMH\$PHt$XH|$`Ld$hH@]E3HT$L$USVWATAUAVAWHHXHcAE]uV38-	3;fHLL
sIK HkXD1lv8_D>6HtDl18AEAADm`tuШtL`ШtA;AB؋lLHuShMH3DBgL
LK L\0@K IA
D0HL0	A:AK AAIVE`DD0	EtbK L09A:tQtM
K AHE`DD09Au.K L0:A:tt
K HE`ADD0:K LMDH1H|$ <HcU܅|H;qLDK D05At
A>
uL0d0IcIMIHEL;A
AE<A:t
HIHEHL;sIE8
uI~LK LMHUXH1AIH|$ <u
A<uf9}taLK D0Ht}X
tD#K EXD1	;I;u}X
u
+MHAH2}X
LctLXD#HL;mK D0@uL0	AEHDE+}`EHuHI;rHB8VtBVuR*u;uHcH]K D0Ht;HÈL0	|K HÈD19uK HÈD1:HcH+MHAHcELmPA+DMƉD$(3ҹLl$ u:Du:;Ë]HJ @E|0HҺ
t
fA9uL0d0IcIMIHE`L;eA
AEf.fA;tfHIHE`HL;sIEf9u	ILK LMHUH1AIH|$ f9u99}LK D0Ht;
f9Ut@fD#EK D1	EK D19K T0:LI;u
f9Uuf7MHHDBf
Lf9Ut
LfD#HL;m`"K D0@uL0AEfHDE+]LmPM;tIqAD܋Y8u	Amu뵋,38h	UHXA_A^A]A\_^[]H\$Ht$L$WATAUAVAWH ALHcu:3ۉ	3ۅ;=v_LLIL=s_AMkXKBL tiAuW]	KBD tDIՋz		zS	@H\$XHt$`H A_A^A]A\_H(dHt
g,tA@AH蟷ų̋+D#AD#DD+@UATAUAVAWHPHl$@H]@HuHH}PHH3HEHEDD`ME3E3AA35Hcu3~g3HBHHrXHL6Hw1HAH;w
HHz{H+H\$@HtoHHtHHHtDLAA:5t9E`A3H|$8LAH|$0u|$(H|$ 	D$(L|$ 6HK9unHMH3fH]@HuHH}PHeA_A^A]A\]H\$Ht$WHPHHL$0IAjD$HL$0LDNjD\$ e|$HtHL$@H\$`Ht$hHP_H(HuHH(LH
:3H(H%3̹αH\$Ht$WH@HHL$ AAiHD$(DA|utHD$ H@BY#3t|$8tHL$0H\$PHt$XH@_H‹AHE3n̋AE33ZH‹AHE3B̋AE33.H‹AHE3̋AE33H‹AHA̋AA3H‹AHA̋AA3H‹AHA̋AA3gH‹AHAWK̋AAW33HAEAHA3EAH‹AHE3̋AE33H‹AHE3̋AE33H\$WH@HL$ HgL\$(Mt2A{u(AE3Hl|$8t#HL$0|$8tHD$03H\$PH@_3HHXHhHp WATAUAVAWH@LHHHEMfMtM.Mu*螴|$8tHD$03EtA|A$AuLD$ 3I]A~LD$ @κLD$ I@@Ht@3H뾋$@-u@+u@3HEu&@0tA
6;xt
;XtA$AAu@0u;xt;Xu@sHM@Mc3HILL@EOAȃt	@փ0At/F@<w A;sI;r%uI;vMu H@uMIE3pIHϋH@3HH@u%@uFŃtHH;w	u,H;v'"@tH@$HHHMtI@tH߀|$8tHL$0HL\$@I[0Ik@IsHIA_A^A]A\_H83EL94D$ Hu	H
3mH8H8d$ IELHHKH8H8=A4ELHD$ u	H
3H8H8IELHHD$ H8@SH d$@LD$@HHu9D$@tHtL$@HH [LMt;E
IAAwA 
HAw It
EtD;tD+A3HHXHpHxL` UHH@MHHMHMIScHu+
}tHEHtIwHExu!MHH)}tTHMGH+7HUHUHItt;t+؀}tHM3H\$PHt$XH|$`Ld$hH@]H(=U2u6Hu5"H(HtIwH(qE3H(H\$Ht$WH AMLҋHuؿįMtT$PHHHL;w袿"AA";w3M…t
A-MBKM3ҋ	vW0AHItI;rI;rA@hAIAAAA	IIM;r3H\$0Ht$8H _H8A
uy
D$ d$ H8H83A
uyAAD$ H8H8d$ H8H\$Ht$WH AMLHHu胾oMtT$PHHHL;wM"ȍF";w3M…tA-MBKHM3HHH	vW0AHIHtI;rI;rAdAIAAAA	IIM;r3H\$0Ht$8H _H83A
u	HyAAD$ H8H8d$ H8HHXHhHpHx ATH0IcIDE~HIh
HHcD$hH|$`~HHL
t tD$(DLƋAH|$ )+ظHHDH\$@Hl$HHt$PH|$XH0A\̋…tȀ9t	Hu+ЍB@USVWATAUAVAWHhHl$0H	H3HE(L3DEMULLeA~CIA+׃8t	IDžuы+~)IA+8t	Iׅu+;}3;|DEuIDpt;u
WA;~AJA;~
;HUA)t~)}r8]HEt8XtAM:r:HvH8~-}r8]HEt8XtA$:r	:HsH8DMź	AΉ\$(H\$ (LcI~f3HBIHrWKL?Hw0HAH;wIH7mH+Ld$0MA$waLHtILMDMźAD|$(Ld$ Y'LEDκ	AΉ\$(H\$ 3'Lc~g3HBIHrXKL-Hw1HAH;w
HHmlH+H|$0Ht{`HHtHHHtRLEDκADl$(H|$ &tUMEMDl$(H|$ &HO9u_IL$9u_HM(H3WHe8A_A^A]A\_^[]H\$Ht$WH`HHL$@IA[D$$HL$@D\$8D$0H$HD$($LDNj։D$ V|$XtHL$PH\$pHt$xH`_H\$Ht$H|$UHH`HHHMIIZHu8]tHE3Hu(蒸}tHExHtHwHEPuLMLHH:@HMLΉD$8\$0AH|$(\$ u
넃}tHML\$`I[IsI{ I]̃=)uE3H\$Ht$H|$ ATAUAVH MMHLgHx0H|$H3Hu脷q9HhHMMHHA֋H׋HhH\$@Ht$PH|$XH A^A]A\MLHH
CMLHH
+MLHH
(LHH
E3LHH
˰E3LHH
E3HHHd$0d$(AH
HE3ɺ@DD$ -"HVHHH(H
EHtHt;#H(HHXHhHpHx ATAUAWH H33DG9LHtPDG3ҋ#Ht=HH+H#AWHE/#HHu1讵裵H\$@Hl$HHt$PH|$XH A_A]A\ú^DDI;HEMNj_7tHH+H~i8u?
HAԋa"LH3"Uy]E3HՋ>HTAH HHHHu%ִ
H!HE3IՋH3H\$Ht$ L$WATAUH HHcu葴 G;=Hs~HLIL-HHkXKDL0tW3Hu> IKDD0tHӋ	B ˳	跣H\$HHt$XH A]A\_H(HcH(H\$Ht$WH HcAHug	RDE3Hu* 3t	oHHHGHHHkXdH\$0Ht$8H _H\$L$VWATAUAVH ADHcu Ȳ	xs;=3GskHLIL54GHkXKLtEDKDtDAԋb	w a 9	&H\$XH A^A]A\_^H\$LcHFMAIMkXJBD8F\ADA@tXtHt(t uHBLJBd8BL80BLJBd8BL8BdBLJBd8EuA%@H\$H(@t'tt'
7-3H(H(Hu

-3H(H\$Ht$ L$WATAUH Hc@t0t(t tt菰u
z	}xi;=DsaHLIL-DHkXKDLt:KDDt
Ӌ
	q	H\$PHt$XH A]A\_E3AHtfD9tHHH;r%%%% %"%$%&%(%*%,%.%0%2%4%6%8%:%<%>%@%B%D%F%H%J%L%N%P%R%T%V%X%Z%\%^%`%b%d%f%h%"%%%%%<%.% %%%%%%%%%%%%x%j%\%N%@%2%$%%%%%%%BH8Mхt+;tA;u"HD$xDL$pLD$hHT$`IHD$ ̋H8H\$WH H3HHW0LHt4HȊt&<"uH	AIHÊutAH|S3H\$0H _HHXHpHx ATAUAVH0HHE3L!pANYu3L3HL$`atuL!t$ E3E333.̅uHL$`Ht3uH\$`5Ht3Ht"3H
HH
FHEHtHLHBL0DHHLAHHuLd\A8$u9H%L;t_LAH҅tIHd$ E3E3339A<$/t,LIH蟅tHd$ E3E333Ht(LIHrtHd$ E3E333ٚHL$5
D95'B5n
D5'Z
Z

R
+=v:HDQ3BMM+LA
IYu3 3Ht8
t,Hd$ E3E333	Hd$ E3E333HL$`P3PHH\$PHt$XH|$hH0A^A]A\H\$Ht$WH03O3ۉ\$ ;RQ}\HcH.AH<tGHBt=[HAHAtHy(talj|$$H@H\똹H\$@Ht$HH0_H\$Ht$WH@HًHL$ I3KHu'跩褙@8|$8tHD$03~LD$(A9xuHh^@8|$8tbHL$0TBDt%HÊt;uH{HuH;HDHÄu8L$8tHL$0HH\$PHt$XH@_E3@SH Hu
 ΘPuu譨'u!tt跨茨
3H [H(wH(@UH HAH ]@UH H&H ]@UH@HML}H@]@UH HHMPYH ]@UH HHM0YH ]@UH HHMHYH ]@UH HHM@iYH ]@UH HHMxOYH ]@UH HꃽtgH ]@UH HHHыuNH ]@UH@H.H@]@UH HH ]@UH HH ]@UH HH ]@UH H
H ]@UH H
H ]@UH HH ]@UH H
qH ]@UH HQH ]@UH H
6H ]@UH HH ]@UH H
H ]@UH HH ]@UH HH ]@UH H
H ]@UH HH ]@UH HeH ]@UH HHE`H ]@UH HH
H ]@UH H
H ]@UH H
H ]@UH HH ]@UH H} u'HcUHHHHLA9HkXIdUHH ]@UH HHMH3VH ]@UH HTH ]@UH HHcM HH;H'L'\'l'x''''''''
((2(D(Z(n(((*110'0000000z0j0T0D0*00///////x/`/8/*/'''&&&&
1&&&x&j&\&F&6& &&%"/:1/...+,,,4,N,l,|,,,,,,,---0-B-V-r-------.&.2.<.H.Z.h.v......+(((H*:*$***))))))))z)f)Z)F)2)")))((+++@@H@h@8?@K@@ܯObttCreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.5\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\Please wait while running postinstall script...-installIsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptnamemetadatatarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfainvalid distance too far backinvalid distance codeinvalid literal/length code`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

incorrect length checkincorrect data checktoo many length or distance symbolsinvalid distances setinvalid literal/lengths setinvalid code -- missing end-of-blockinvalid bit length repeatinvalid code lengths setheader crc mismatchinvalid block typeinvalid stored block lengthsincorrect header checkinvalid window sizeunknown header flags setunknown compression method inflate 1.2.5 Copyright 1995-2010 Mark Adler 	

#+3;CScsI	
!1Aa 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionaryХ@@h@@@@x@h@P@h@fFK
I*TK
ITTK
IO :i+00SBi+00@_dP/N  !:i+00'":i+00
E%6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF΋!	Hx5i+.b`ODV	AH
FM^2mFT
d_N"
(2W]/4*&{-zeG'{-ph}OUBlOU3(9O> G e+.bchOU4^;ݧB}/NKfNr@"=3H$Oڠ'my4[J1B&M[OrG:ᠷqEJ ǬMWs5i+.bs5i+.bs5i+.bw~s5i+.b%e{HqC,40L]0RO$[Dt.+*U6F:(Y;a-kQG^)|I)sO>+dWnO@;>V;>V
Wt חb@J7<}iFϦODa'wj5Ob0wDObAGQ`{FL!mv`[c'wj5Obd'wj5Ob6J[CAVgqe'wj5Ob5i!Lz)zR88`[|^1/`[@L\J7@呰 חbu`ެ@`ެ.PRO—-T'tE`ެA`tpZdl?<W4plTI?rPB,ɨ=O${aPo0p,oiyŜ?Oɝa4Oص,OꙠς`RWpO6OyѦjc(=O0%G`묡51Mlg~6JNfsv]=D%Ocg3K@~Oq!2)wKL+2V4K@~OqT'B6Q:.7V`ƆEz5K@~OqiI~+.ͩpO]_eOkm'WFAOлP0P0P0M]`gI6FOEг]K$^5N$̈&HS3M17i;'$9Y:Oh7%9Y:Oh7&9Y:Oh7'9Y:Oh7ի|I˃(9Y:Oh7!FsGF{H@FS2IEt$#CȫR
e.{ JOe/P($IZ^9$\E9O奄`OO\;x8WFTpjzO1I(
@wiKw^ևA)!\_[C+dWnO4DLe+.bSmb`ߌ #Or'>O.jxO^QmOd4'>Or3߷;`[MOKLb`wG:J'i>VMYFDAt;&OF}Ҩ\I;%S|
*E
yЎf|txMNI{@>KJ\FЗ4mc-NvEc7VfCNItwׄ8A!ӱJ'8EK}4@VqC(DW@XzvF@S>LNdL֬+o.Eцݷ"JL
:̿,LB)隇A }jL^6CTw]+.DJQS[bHNAFPCU	.4zl'K@-tК#FlHiawhM0Y3S!AbostA^?UX2NfHyu	5ꥂG)]/qNnN9jI=W.I|Kg
4cH~%]bM
I]7BWGCQl2$HܨEye64ۅ>eL:er='oOU{p OsCů$53QB`ϝ]v+qAO;ل.CZ0YcwN]ND.Q1RWHΨ}'CBg(#l^"`G3qs03NvFZ9\;û@Z|KJ$M>MEQ wmjKDWw? ec
E
kjO}c^NIe2mG)f\"gJ]lV`W0\"F-V
pNr-O&oO}N8úGˢ)qKmHB" C[E|tKpȞ&Aõ*iG2HNOiNㄫ9O'HKlqto%yL%4FxWObDcq#	(O\iN`|\1IkLICN_3haO1FI&I}!<OGFVXia;B8n29֔hJuAtXJQxd_w~8ƏWU]O	Ɋ36(A#)V)F#Ϋ>%'GoGG+}.аvLX]p`OK #7EC)t0ō*ƾ{,D
Jև+DW^
Oor9tRNNgɆ>!OL'`g+$%|QOz)(B_@^A% xSDMt	Nn8Åm]rLwx,4Ku@+׉#G``WG 35A	AlG؂تI`FtQ<[MEĀd_NM&uf4L3lEZIC~"@0(9A8L"k1%B	T
#=E\\GNˇbR
FHspSi)!@'QL.JiFFFFFF F F!FFFF&FFF	FFk!Pi)?F0:s*Dw=F
FFF
F
FFFFFPF%FQFFFF`k;Yi+-z1OY
ȿ4<OV%
X$5I?#3:O4j;Yi+-zj;Yi+-zi;Yi+-zv nr=F>F@FDF[Fʙ^AiXשFh
Mm8gh
z0Gd<O8mxO4yO"FFFMm8gh
0F1F2F3F%F)F*F0:s*Dw=IFy.Y+F&FEFGFHF:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/Oǝv\Wސy(_FFFFFFU
8r+C+n44FâRX0eu{ڮP9Vu{0ne0E
Kvne
yOܦϫ|xOjIOQnO09$-1.E^*onePone |~|?ne?PE^#1$-?W2$-?W2$-pw~?neg@ne˳j@ne˳j@ne?W2$-~{S^BEy|KDphKΔӳOհrIOC'zO{TxhO{lhO6ǀ_`\`OOrOh7y)
Oh7BTyI6E&jnLFB}sg'Dx+h\t<6M>?i]?9A!8ҏFs%E~2]r?jdN&6u^gO!B>9}Nr*GݓkFN]ͷghhϓgAc*^Z%Ȕ2AeqKW';?B@
J$SQ`Ɔ(œO>1s-O(hHjxOiQD(ߥl+ rˆLmCBUa{Ӱ~C.`1y/DĊYF;aAdƼ403bpc(Jg
Дէ{E]E)ПS-oEH?syYz(y
K@AXGA'qQUAJ
sY!WOZ{*lg(M2(TfC'>|a. 	O;O.K[K8H]҇26 -&{-r:
%wCjW'tVamy!@iaWBVm`ɠI-`:Bn5OC(K鞟^ﯘ=ѕK0:ښL%2J4{[kYs=BMQ!B\[/B{NsASÖ.̆I#t9JDf?kјH"tŻ-Gs?zZAe!`[ǽ6NXX$KiiőԞ(LqmjKH(.~,-Y@o3\.QCpg{LKIs<_z\
LKo(t;sM|@)^vJYӞ~+IzÊChsxDpWJ?,CP0DOAoZ\q"tDk׾TLrTIkE
a`NNe76_I|kHrYM>s:
.jxOˡd:aDX7iii9P5}+EutX(T6QB~ۜC]_#ͼ_Ld=xr|խhG2`?uIp4Bf6חKt3OtaG'"v0
SNwL1"(iv@	YGح+ObC4`[ԄLr?RJ{,AsEOWL"O7v8yOhKKt&1Zs~:6B}Ftr⋪GMv2̤pDʹfD.b[GvtH;
zr\GڙYkH?FA&OA;,Ui6
IJ"x9J4ܵ;EfDװqmrE.1!YuY&HxHϣ'GVBeUNOخ|)IE@0lyדسDg,ݠeL3"5/QqCAwSk5X;-3B{_41lxpOh6ǾƱLb
VBPoz5zD #D@Fgm[M/BT|\?@zpDF[0	49Z
I}AaB}KX䌠%D|DZ#`ڽWvGE>ςZ#@k{X8&oIQd5CvSdn0@DH&'E4VwҁnB*O&-bfMlV!j

hFXapf_:qJ?򥸿2cpF^W5}3ƔHjiOY<0G==
6eFpqFwHҶe_K#q}kdO-p;z5Og5е.Í}DwMm3sG%`4n.8E40PpZdFK6eJ7`, :i+00Fh3MnMܙS{5)xKt	O3CKsw`$D&l;0MHֿRUBu(dT&arrCuƋ.|uU:WPHw[ێ	Z܊M`* !sG3^F0MJSkyZ
8y
M3,/KqI\M;TQ'CHCh4-6C$/`zLbeLWwR"!5C34a@Y?JTwZ8KMn錕Ra/pam/pmCorExitProcessmscoree.dll@a@a@TZSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunLC_TIMELC_NUMERICLC_MONETARYLC_CTYPELC_COLLATELC_ALL@t@@M@H@@M@L@@M@@@M@h@@M@$@	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;runtime error 

TLOSS error

SING error

DOMAIN error

R6033

- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.

R6032

- not enough space for locale information

R6031

- Attempt to initialize the CRT more than once.
This indicates a bug in your application.

R6030

- CRT not initialized

R6028

- unable to initialize heap

R6027

- not enough space for lowio initialization

R6026

- not enough space for stdio initialization

R6025

- pure virtual function call

R6024

- not enough space for _onexit/atexit table

R6019

- unable to open console device

R6018

- unexpected heap error

R6017

- unexpected multithread lock error

R6016

- not enough space for thread data

R6010

- abort() has been called

R6009

- not enough space for environment

R6008

- not enough space for arguments

R6002

- floating point support not loaded

@`@	@
@P@@@@@@@@@P@@@@ @!@x@y@zx@p@P@Microsoft Visual C++ Runtime Library

...<program name unknown>Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODESystemFunction036ADVAPI32.DLL	         (((((                  H          h((((                  H                                 H	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~united-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamerican@ENU@ENUx@ENUh@ENA`@NLBP@ENCL@ZHHH@ZHI@@CHS(@ZHH@CHS@ZHI@CHT@NLB@ENU@ENA@ENL@ENCp@ENB`@ENIP@ENJ@@ENZ(@ENS@ENT@ENG@ENU@ENU@FRB@FRC@FRL@FRS@DEAh@DECP@DEL@@DES0@ENI @ITS@NOR@NOR@NON@PTB@ESS@ESB@ESLx@ESO`@ESC@@ESD0@ESF@ESE@ESG@ESH@ESM@ESN@ESI@ESA@ESZx@ESR`@ESUP@ESY8@ESV(@SVF@DES@ENG@ENU@ENU@USA@GBR@CHN@CZE@GBR@GBR@NLD@HKG@NZL@NZL@CHN@CHN@PRIx@SVKh@ZAFX@KORH@ZAF8@KOR @TTO@GBR@GBR@USA@USA6-OCPACPNorwegian-NynorskGetProcessWindowStationGetUserObjectInformationWGetLastActivePopupGetActiveWindowMessageBoxWUSER32.DLLEEE00P('8PW700PP (`h`hhhxppwppCONOUT$TMPRSDS# ,H0FHC:\python-dev\porting\cpython\lib\distutils\command\wininst-9.0-amd64.pdbdT42p
dT4pT4p04=4
p`PȑT42p20

4
2pd
T	4Rp
4,
*pȑ@&4ZXPȑ+tZ4YVPȑ
42
p`P'%#
	p`0PȑdT4ptd
T	42+T$4#p`ȑ
4
pȑP*p`ȑ d
T4
rp

4
Rp$	,	p`P0ȑPp`P0ȑ4	#d#4#pPȑ
4

pȑ@!0ȑ0&	44,
p`PȑP

4	
Rp204"t1"d0"4/"*ȑ@3"tY"dX"4W"RPȑ+ȑ@)	t3d241.Pȑ`Bȑȑȑ&4dbPȑdT
4RpdT
4Rp2020d4
rp=
,t,d,4,PȑP'	T9482p`ȑtd
T	42BB&p`P0ȑ04$"P/	dT4
pȑ0bt4t
d4tdT4B)	t*d)4(&Pȑ 	b
	p`P0dT42pd42p
t	dT42	
p`0P20dT42pd42p
d
T	42p*4
p`Pȑ20B		R0rp0Pd42p2020td4rPbbbb

2020d42p4R
p`P2P20x-|0M2Pd42px-ߟKMrP,d4
p1tfM2PBp`0x-$MBBBBB20B2020p
`0P		bdT
4pbdT
4pbbbb

4
2p2P42px-íͭMd
T4
2p2Ptd42x-ƯگMB
tdT
4
tdT
4dT4p

t4t
dT4
R'E4C
p`Pȑh##t#d#4#Pbbb2Ptd
4	Rx-UwM|M20p0PBb		bbbb		bBBBBr0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r020r020!!

d	4T2p!0!,
, ԁtd40

Pd42p2PRp`0x-M20202042p

4
2pBB

4
2p2P
d4rpx-N20202P	

4
px-%NB.	d4pPȑ

4
2pBbd
T	4Rpbbb202020rP
p`0x-eCNeCNT4Rp`
dT4p2PBx-L`^N2PBx-yN2P20x-NdT42pd42pBBB
t	dT42BB2020202020d42p20d42pdT42p/	td4Pȑp2P

4
2px-"yNr04r
p`Pȑ82P
t
d	4Rx-NBd42p202P20x-CYNB2P2P

4
2px-&0OEl O

4
2p202P2P42px-;OB[O2020d	pP

20202P2P2
0x-<`vO{O2P2P

4
2px-09OPWObp`P0
td
T	4Rd	4RpdT
4Rp&

	p`P0ȑ04MB
p`Pȑ$		p`P0ȑ
t	dT422P2P2P
t
d4
Rx-0[O/P
L,PBB-dQTP4OJpȑ@B

4
2p20dT42pd42p
4Rp`
Pd42pd42p
4Rp`
P2020
t	dT42
t	dT42
t	dT42
d
T	42ptd4
rP  d T 4 rptd42dT42pB2Ptd42x-?1}1GP

4
2p
t	dT42dT42pT42pB2P
	td42x-44eP2P2P
td
4rx-55P\56P2Ptd
4Rx-78P"	
	p`0PȑhtT4d42pt42		2020dT42pdT42p04dZ
p`PȑB2P
td
42x-pK,LQbbbbbb2Pd	4Rpx-BMMQd42p202P2P
td4
Rx-NBO8QN[OhQ2P42px-OOQd	T42pd42p20BBd42p04ZP
p`Pȑpd42p20BBd42p04ZP
p`Pȑp

4
2p2P4
2
p
`x-vwQ206%4q%f
p`Pȑ 2P42
p
`x-aQr0r020202020td4
rPB
T4Rp`2Pd	4Rpx-RrQdT
4pdT
4p
td4PbbR0b
td
T	4Rbbbd42p	Bx-юՎՎB	Bx-B2Pd42px-͏QBB2Pt
d	4Rx-ǑْR2P
d4
R
px-iRdT42p$		p`P0ȑ
d
T	42p202P
t
d	42x-t8RB

4
2p

4
2p

4
2p2P	Bx-PRBBdT42p

4
2pd
T	4Rptd
T	42d4
Rp
t
dT4
r

4
2p20d42pd
T	4Rpd
T	4Rp2P20x-)4rRRP
t
d	4Rx-xR*RRP
t
d	4Rx-uR/R1
dT4pȑBBBB-
Etd4C
PȑHd4p-
5td43r
Pȑ0d4p
td
4rP2
0T42p

20dT4rp2
0td4rPBB20bȑ td
T	4220

4
2p$d4pȑd	T42p$T4pȑ
4
pȑ202020T4Rp`bȑ 	p`P0ȑH202020BdT
4pBd	4RpT
4	Rp
td
T	4RdT42p
td4Pd	4RpT4rp

4
2pd42pB2PBp0x-RBBBBB4p
`Pbd
4pd	4Rp20dT42pdT42p04dZ
p`Pȑ

t420dT42pdT42p04
p`PȑX2P4
2
p
`x-SR

4
2p2P42
p
`x-S20

4
2p2P42px-S
td
4P		b2P20x-6S

20tP$
$4$p`PRPp0x-QSRP

4

rpx-Sr0b

td4
rP

td4
rP	
p`0
P2P
d42px-*"+SB-
Etd4C
Pȑ@d
4pBd4
rp

4

rpdT4rpbbbb20

td4
rPBd42pbbbd42pbb
td
T	4R$
53
	p`0PȑXd4ptd4P2P
td
42x-!>G>TBtd
T	422Pd4	2px-AATBd42p2P42
p
`x-	C;C4T4BB2Pd4
2px-UE|EMTb

4
2pRP
t
d4
Rx-JJfTJJfT2P2Pd	4Rpx-SK}KT"KKTd4
rp20B %P`0!(`$T*Hd *h` +`$+8d%+ e:+*+n+^+L++*+*%%*****r*`**>'L'\'l'x''''''''
((2(D(Z(n(((*110'0000000z0j0T0D0*00///////x/`/8/*/'''&&&&
1&&&x&j&\&F&6& &&%"/:1/...+,,,4,N,l,|,,,,,,,---0-B-V-r-------.&.2.<.H.Z.h.v......+(((H*:*$***))))))))z)f)Z)F)2)")))((+++PropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastError|CreateDirectoryAGetFileAttributesAYMapViewOfFileCreateFileMappingARCloseHandlexSetFileTimeDosDateTimeToFileTimeGetLastErrorCreateFileAUnmapViewOfFile`lstrlenAiMultiByteToWideCharLGetProcAddress>LoadLibraryADeleteFileAReadFiletSetFilePointerGetFileSizehFreeLibrarySetStdHandlekGetStdHandleJLocalFreecFormatMessageAGetTempFileNameAGetTempPathAGetModuleHandleAGetVersionExAResumeThreadSetPriorityClassGetCurrentProcessGetCurrentThreadSetThreadPriorityCreateProcessAGetModuleFileNameARemoveDirectoryABGetPrivateProfileIntAHGetPrivateProfileStringAGetModuleFileNameWKERNEL32.dllMessageBoxA.GetFocus:wsprintfASetDlgItemTextA{SendMessageAiReleaseDC#GetDC6PeekMessageADispatchMessageATranslateMessageEndPaintGetSystemMetricsBeginPaintDefWindowProcAUpdateWindowShowWindowmCreateWindowExAORegisterClassALoadCursorAMoveWindowGetWindowRect9PostMessageAfGetParentvSendDlgItemMessageA)GetDlgItemSetCursorUSER32.dll6CreateDIBitmapDeleteObjectSetTextColorTextOutASetBkModewSelectObject<CreateFontATCreateSolidBrushGDI32.dlllRegQueryValueANRegEnumKeyExA0RegCloseKeymRegQueryValueExA`RegOpenKeyExA}RegSetValueExA8RegCreateKeyExA=RegDeleteKeyAGRegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dllpCoUninitializeCoCreateInstanceBCoInitializeole32.dllGetSystemTimeAsFileTimeHeapFreeHeapAlloc+FileTimeToSystemTime*FileTimeToLocalFileTimeGetFileInformationByHandlePeekNamedPipeGetFileTypeEnterCriticalSection;LeaveCriticalSectionGetDateFormatAGetTimeFormatAHeapReAllocGetModuleHandleWExitProcessDecodePointerGetCommandLineAjGetStartupInfoWTerminateProcessUnhandledExceptionFilterSetUnhandledExceptionFilterIsDebuggerPresent&RtlVirtualUnwindRtlLookupFunctionEntryRtlCaptureContextEncodePointer WideCharToMultiByteGetTimeZoneInformationxGetCPInfonGetACP>GetOEMCPIsValidCodePageZFlsGetValue[FlsSetValueYFlsFreeGetCurrentThreadIdXFlsAllocHeapSetInformationGetVersionHeapCreateHeapDestroy4WriteFileeSetEnvironmentVariableWdSetEnvironmentVariableASleep%RtlUnwindExInitializeCriticalSectionAndSpinCountDeleteCriticalSection&FatalAppExitA|SetHandleCountGetConsoleCPGetConsoleMode;SetConsoleCtrlHandlerALoadLibraryWGetLocaleInfoWgFreeEnvironmentStringsWGetEnvironmentStringsWQueryPerformanceCounterGetTickCountGetCurrentProcessId/LCMapStringWpGetStringTypeWGetUserDefaultLCID
GetLocaleInfoAEnumSystemLocalesAIsValidLocale]FlushFileBuffers3WriteConsoleWHeapSizedCompareStringWCreateFileWaSetEndOfFileQGetProcessHeapSoftware\Microsoft\Windows\CurrentVersion\Uninstall h@h@h@h@h@h@h@g@g@h@ h@g@h@g@h@h@h@g@g@h@g@g@g@xg@`g@Hg@8g@ g@g@g@f@@f@@@f@@f@4N@f@xN@f@(@Software\Microsoft\Windows\CurrentVersion\Uninstall2-+] f@@pPSTPDTF@F@
		


!
5A
CPR
S
WYl
m pr	

	
)

                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZH@`y!@~ڣ @ڣ AϢ[@~QQ^ _j21~C@@@@@@@@@@@x@l@`@\@X@T@P@L@H@D@@@<@8@4@0@(@@@@L@@@@@@@@@@@@x@	p@h@`@X@P@H@@@0@ @@@@@@@@@@@@@x@p@h@`@X@H@0@ @@@@@@@@@@|@t@`@8@ @M@M@M@M@M@U@@@@M@P@P@H@@
X@H@-@-@-@-@-@-@-@-@-@-@;Zx0Nm:Yw/Ml..U@U@xq@xq@xq@xq@xq@xq@xq@xq@xq@U@|q@|q@|q@|q@|q@|q@|q@@@.$$Y4lXJh`p=|@&(o p ##$ $%<%'X'(|(%*(***c+d+,,<-<-..!0$00(01<13P3"4p$44|4"9$9G=H===2@4@t@t@AAeAhAA$BC4CDLDE`EFtFPF|PFbGdGKK-M0M4N4NvNxNNN-R0RS$SV4VWTWZ\Z&[d@[I^lL^a|a'b(bc0cgghh]iijj34$d,փ@Ph00ddǑȑϓГ ehŗȗi  BDwx$ݛ,040<hLhhƣȣ(508\8\y@|HPX`EhЧp ѨxԨrgh~&(]`ɬ̬z|np@/l0htp0	EH(08H:<]`9<'(
opS T(:0<8#@$HPX`shtp_x`KL.DY\{{}0jjwxK@LX78klW0 H*P4Xx14104oPpx;<kl"$N,P4<DL\1dht0080@Py`,,_`$	1	,	4	
4	P

D	

L	 d	l	x		&
(
@,
@ML
Psp
t
p
py |DL0cXd`{ t| 7$T$$$_%`%((])`)))****!+$++,+h,H,p-Lx-u/`x//|/00001111|2|2)3
,33
3L4(
L448
5$7x
$78
 8:
:==3>(4>?8???H@??P??X?Z@l@JJ
KKPLPLsLtLLLLLLLMM'M(MMMMNDPNNTNOlOOOeQhQQR2R4RYR\RoRpRRR(c$(ccHccXc
d`d#dh$dhdphduuvvSwTwww~~@[HtṔX́`$h`6p8~68ćЇȈWъ,Ԋ	4z<|D܌L܌d-l0eth|ߎ%(EhH\\pp-$0bXlppKTHH ( V4!H$ehhpx
@HӥADܨ0ܨGLHEtHJLll$,+4,d<JDLlB|Dµĵ34"$hh,G4L<[D\Tpx<!$QT\,\HPX ``hh$|$ad!DFPNP7$84X)`,ShTupxx34!$OPE H4
H
tY\?@u4Dvdl|y|NP!!# #C*,D*_+L`++|+--z-|---?.000230303R3T333333<4?5$@55<56D66T66\66d67l77|88888<<<<==k>>7? 8?Z?(\?@0@ATAAABBsCtCBDDDDDDDEGGG1H 4HK4KKKLLMM"M0MKM`KMfMfMMMMMMMM8MM@MNPN%N%NCNCN^N^NyNHyNNpNNNNNNNOXOO O;O;OVO[OvOvOO\	OOT	OO	OO	OP
P'P
,PGP
GPePePP0
PPp
PPh
PQ
QQQ8Q8Q`QdhQQ\QQQQQQQQQRRRR8RP8RNRPRrR@rRRDRRlRRRR,RSlSSS6S6SQS<QSSSSSTDTTT4TL4TMTMTfTfTT,TT|TTt(@pnklmn	(	8	H	X	hx
 $ZZ(n,	BBB999111)))cR[RABZRYRZRAB[R[RAB[RAAB[ && &&&@JQ1AA1ZQ1111ZQ1AAZ@JQ1AAZQ1AAJ eu eu @ABZ@J@G@F@F@G@AABX@J@AABX@J@J@AA1X@J@G@HRX@G@AAG@ZRX@AAG@JQJed%ed%ed@AA1ZQ1AA1X@J@HQ1AA1X@1A1ZQ1AA1ZQ1A1J  & & RAABZRABZR[R[RABZRYRBZRABZRBW@J@J &R[R[R[R[R[RABZR[R[R[ & & & & & & &@J@J@J@J@HQ1AA1X@J@J@J@J@J@J@G@J@G@JQJ@ABZQ11Z@J@AAG@J@G@GQ1J@AA1ZQ1YQ1[@J@AAG@J@G@1W@J&@I@G@J@J@J@J@G@J@G@Z@J@AA1X@J@HRABX@J@HQ1AA1X@J@J  &  %& & & &RAABZR[RZRAAABZR[R[RABZR[R[@H{SetupMS Sans SerifP}
This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.P}PhnP}@H{SetupMS Sans SerifP}
Select python installation to use:PP}7Python Directory:P}jPhnPP}BInstallation Directory:@B2Find other ...@H{SetupMS Sans SerifP}
Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.P}msctls_progress32Progress1P}Installation progress:PhnPA@H{SetupMS Sans SerifP}
Click the Finish button to exit the Setup wizard.PhnP}(
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/wininst-10.0.exe0000644000175100001730000056500014467657412024254 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$[ɏɏɏQɏqb;ɏqW	ɏJɏZɏȏɏqcɏqSɏqTɏRichɏPEL{O
50@Pg02@0.text `.rdata0@@.data$M@.rsrc0@@tt/u\@uUVuS]W2B>toj\VgYYt_ST1BEu&jSX1Bu9EtSWjUSjUYYEuh\1B}t
SWjU\Fu_[3@^]USVW=81B39uuEVhuVVSu׉E<1Buu uuuPt	P\1B/9u ujU YYt.VhjVVSu׉Eu%9u uh@3BujU YY9u t
ujU YYEPuu@1B}EPPPWD1B9uu	WH1B\VuVjVWL1BW=H1B׃u9u t8uh(3B&VVVjSP1BSE׋E;u9u tuh3BjU 3_^[U8}S]VWj8EjP,jEEȋE@E̋Ej8h3BE؍Ej3P]FF}tt*Ph|3BEjPHYY;tt
Phh3Bj׃3EP7[Yt,t
PhP3Bj׃339uuuuS!fFS41B_^[U@B3ʼnEEMEW}L8+AQ+ƒ9PKt33SVf;Q
|3@^[M3_jËs*;PK>PKS.K SFC*NȋύDM+AuP@u+I<\t"OGGu3BfP,1BGP@u+PQȃ8uFPP$h6P@u+€<\tVCPCPsPjt(NssQPt$@P@
Pj@
94ȋx@uN+NjAu+΍OOGuʃ󤋍ȉI+ȍp@u+Ɗ<\tj@9BY3tu%u%YCtuh,9BPfM3_3@^XUQQVW3VhjVjhu81Bu3NSEPW0BVVVjVWL1BW=H1BE׃}u3VVVjuP1Bu׋E[_^U=Ct@=Cu7Vu|2BCP
jHQRjQVL0BVuC2B^]UB3ʼnEEL+AV+AW}"43҉9PK>{V4tR9BY;N;t
+V+щC+F+F+~h^YPhp0Bjh9BPl0Btn3PPPvPjt]vWPhp@u+ƍD8PfY41B3@<1BPx9BY3M_3^VUV5p2BW3EPt2BEPx2BjWWWEPօu_^UPB3ʼnE}EEtuuuP`2BSVWMQPd2BjEh2Bj
Yh9B3SSSSSSSjhSSSP40BPu80BjuE<0BCƍx@:u+Nj=@0BPVjjuhuD0BƍH@:u+PVj
j
uuu80BPH0BEPul2B_^3[M3uUU0iB3ʼnEESVW=t0B3VDžDž'@hVL2BhP0B:BPP2BfuVh:Bh9B5 C,2Bh9BP$2BVV׋=h2BPVVjPjPVVVPSVT2BjVX2BV\2BM_^3[UTUB3ʼnESVEPWD2B5h2Bjj֋UȋE++EjRU+UR+PE+EÙ+PWH2BM^3[SUgB3ʼnE}NS]}S=CYtPjhrhS82BVWS<2B+h`Ch(:BP$2B52BPhSh ChSh`ChS_^#Ex8ujjhpS<2BP@2BM33[SUB3ʼnEESQh3SEh:BP0Bt3~SSSSPEPSDžP0BAVW=2BuDžP;t48t0E:u:tN:Hu:u3;5$2BEP\h:BP֍EPh:BPփPhSP0BurhXYDž;tKPVSSS0Bu0\PSh׋VPh0BSSSSPEP0B_^0B3@M3["QUQVEPjjhdBh0Bu	u0B3^UBV;t?=uu/5B'jh,;Bh;Bu,2BƣB^]U}~4B]u}4B}B]UdB3ʼnEENS]VWZ-=82Bt)HEf;sHdCtPjhrhS׻0CShV42BPShV42BPjjhV׉ttjHPhV׀=0Ct.Sh;BP$2BPh2Bu@=0CtSh;BP$2Bl;Bjh\;BP,2B<2BjjhpP@2BjjhV׉uSjjhpP@2B=2B5BVhVhנ5BCCjjhpP@2BjhV׋
BC+Њ@uQh2BjhV@PTYtZShVhHCh(ChD;BSxbu5HC5(Ch4;BhC$2BSTY
5BC5HC5(C3ɊC
AuqAu+΀
\tOOGu3Bf@Њ@u+OOGuȍPh2B@Ex8u43VVhhS82BujjVhpS<2BP@2BM_^33[LU(B3ʼnEEBDž=B=t
Dž=BSVW=0B3SQSjSSSHBVP;t5ujSh=B(2BP,2B3Sht=BV(2BP,2B`CVh`=BPth\=BP^tCPNPlNP`NPh,=BhP#sP5CYhCh =B5CXHh=B5CX5HC5(CVh=BPt PPShSSSPׅtShBhPnpP5C_VC$tPc^YM3HU B3ʼnE}NVuW}u}=$C=@CS2Bh>BhVDž>B3C@uOGGu>B@CfЊ@u+OOGuȡCtQhCh>BPDUhjL2B502BP։PjPtPh>BV@PTthh@>BhMY[FC3;tPWhrhV82B9=$CuPhV2BWWhV@2B3@%Ex8ujjhpV<2BP@2B3M_3^Fh5B 1Bu3h ?BP$1BBtUXB3ʼnE=0Cu3Ah0CEh:BP$2BEPhjEPh0Buu0B3@M3EUB3ʼnEhPDžhx0Bt3@lwu9ps3M3EUB3ʼnEjjh5BhCht?Bj2B ,P|h8?BP$2Bjh0?B|Pj,2BM33EUEE:utP:Quu3]]U`B3ʼnESVWhP3W0BPh?BPmh?BP6mh?BS1RP?BVSRPh|?BSRPVSQ@SZjD^VWPB3fPPh3BWVWWWPWDž0BtO50Bjj0BPh0BP0B5H1B|0B֋M_^3[CUQQSWuj[PE=3ۃ;VGj]W=YY;Fj
V|=YY;tEPhSW5B0BtSht=Bu(2BP,2B2Vu0B;ttSh?Bu(2BP,2Bu0BupIY^_[UQQSWuJj[PE<3ۃ;VGj]W<YY;Fj=V<YY;tpEPhSW5B0BtSht=Bu(2BP,2B2Vu0B;ttSh?Bu(2BP,2Bu0BuHY^_[UVj:u.<YYtFPoYuV1B^]UVj:u;YYtFPPoYuV0B^]Uj[u;YYuV@j]P;YYSFB΋Ê:utP:Quu3tweeWEPjV}E,@Buth@BVP@PNYY}t?tjh?BW(2BP,2BW}GYӋ+_@u3@[^U(TB3ʼnEE3Ƀ}Sj
[tQQhHBBQ,2B3@1VpWjDBBY3t3PPh0BB)h,BBph3YY;u
VVhBBVj(3GY;uVhhPtP@u+‹ND7PYmYuPƄ55Y9|
PQsYYhPQtf3U$8@jpj$hBBhABV,2BBDž5B9j[4Ί:u*tP:Qu˄u3jABYVPPhABV5S;uMj=BY3uBM2@jPh@AB(2BP,2B3@PPh,ABVR;uVYPPhABVR;uVYtSPPhABVXR;tʍPPh@BV8R;uVj<1B;tat\TPPh@BVQ;uVR+PPh@BVQ;uHY9v1Bt<1B~PYt#hp@BP$2BhH@BP$2Bj@h4@BPj,2B\3_^M3[J<UXB3ʼnEESV3BW3@A;u=82BPVhS5CVVhS5C׉5BEc6hhBBP$2BPt6h`BBP$2BPj%jhS5C6h5C2BvmM_^3[;USV5$1Bh\8BWh8BWh,8BWEh88BWEhBBWEhBBWE395Bu3J;tC9ut>9ut99ut49ut/;t+39uh@CUuu3U^[UQEPh`5BuCuujh5BCUQEPh`5BuCuujh5BCUNB3ʼnEENVuW}-tS-t+HPuhhW82BVhW2BVjhhW82B3@eCtPjhrhW82Bh`ChpCBP$2B52BPhWh\CBhWv1t(8jjhpW<2BP@2B5<2BS3SShpW=C$CP@2BSShkWP2BCÍp@u+ƀC\t{GGu3BfÍP@u+WCgSYY85HC5(C52BCt8th33HUBFMuҋ#Ƌ#_^[3tt3uUSVW}j +[7UKu_^[]UB3ʼnE}V33ADž| @|@ ||PP|rYY|P^EYt΍5}t-P|1EYt΍|}u3EM3^)UuMuYY]UuMuYY]UUu3]uE}Y]U@EHPSKLMԋ+MVpWxOωMč:MЋN(M܋N,MN0MN4M؋N8MN)MMMAGMu+MM#+MM;Ms)MMAGMu֋MUvTBj3YM@QmWQWHuE$+ʊQmWQW}w}tQG}vIG;]s7;},@|eB@deB t
@HeBM+)M3AыMKOHM+˃HMJUU#U+ρHE_V8F<^[UM3;t\A;tUV3PQQQFq00PP@P P(P,P0P8PuH8^8MH@}~E@PoB,$ }u2

	σ+}
EME r܋ˋ%;tE@0oB}	33}F@	F@EE9EvEE9EvE}	uuu	E)EE)EE)F@	}T	EMEr܋ÃF`Ã@FdÃ~`F\w~dwfhQE@oB}EMEr܋NhM nBÃfDNpFhFh;F\rFhE nB3fLFpFh~hr卆0NlFLRFTPQjFpPj
E܅tE@nBfh}EMENT3@NLH#ËɉE;wfsK"}MME;r̋Fh+fMfLFpFhf}uW}|MMEH;rڋ+FhDFnEÃf}uZ}EMEB;rڋjÃ7}EMEB;rڋjÃeY+VdNhV`;w6tNhfUfTNpFhHuFdF`9FhsE@nBE@nB>fpuE@nB0NlFLRFTPQv`	FpPjfE܅tE@nBNlFPRFXPQvdF`DFpPj!E܅tE@xnBX}}ri}r`EMuHMHMMHP^8~<]>E^8~}'EM;AtE}t
jm}E+G]+_G_^~Et,t(GS+Ã~PvtW2FG0Eԃu	Eet	t3V҃@UVb@b@b@ c@c@e@f@f@h@h@	j@Uj@j@k@k@Ol@Xl@l@UVut0Ft)N$t"@4tPv(YYvv(V$fYY3jX^]USVW}3;tw;t
]9Ft
>
t
jX_^[]Ã>
uPPPuSP;Ftj׋Gt
jF(};v+PSv4Z
F(F,N4W+SQC
~,F3UEt@t@tMH a03]jX]U39Ev?SWs6Uځ;uAt3jZ+ы@;Er_[]US]3VW;{;9Su
<sjjX9tGG<ȃg8+G<rO8G8DBO8w<sREwh&P5YYswh3&)CC>CYYEtjsSvECsY3jX_^[]UEt@t8
ux<u3@]3]jX]UQQSVW39}u;^;F ;9~$hjv(ЃE;uj}9{4t(K$3@jPv(V E;u
uv(V$YYɋ}jYhuSV%CL00;r/;w%++0FLCP++0FPCl}++0FltK$3@Ps4WE~4p3jX_^[UEt@tǀjjX]UEt2@t+uH@u+H@3ɋ]ø]UB3ʼnEEUEESE3VuWjY}3ɉt9MvEHDEfA;Mrj[3E]Gf|]uK];s;v]uE@E:SljE;vf|Eu@E;r9EsE׋DM+Av~
}tu;uq3jfEYfD
fD
܃fD
r}39Uv(EPf8tLMfOLMfB;Ur؋MtAItMEpBEpB7pB+щUPpB+щUE
}}EMEM>3B3ۃ}]J|]UUxuTs}uPr3@MM*MMM;M}
EfU&~M	UɊUUfE`3fM3ҋ+MBMMMM])U+˃}]u3ҍHBMut	Z#3ۃEfLE܉]u;EEMA|U;,x#ˉM;M}uUM<ȋE3+B;Es)EDEE+Ӆ~AEEE;Er3@UU9Eu
}T}u
}PE]UT+EfT|k*ME@M3fMK}tx#;MtEe>EMM3ҍHBut	J#3ۅuEMt3M_^3[Sø3BjUXUEqB+ȋ]UEEP Y]UuY]%,0B%(0B%\1B%X1B%T1B%P1B%L1B%H1B%D1B%@1B%<1B%81B%41B%,1B%(1B%$1B% 1B%1B%1B%1B%0B%X0B%\0B%`0B%d0B%h0B%l0B%p0B%t0B%x0B%|0B%0B%0B%0B%0B%0B%0B%0B%0B%0B%0B%,2B%(2B%$2B%2B%2B%2B%|2B%x2B%t2B%p2B%l2B%h2B%d2B%`2B%\2B%X2B%T2B%P2B%L2B%H2B%D2B%@2B%<2B%82B%42B%02B%L0B%H0B%D0B%@0B%<0B%80B%40B%P0B% 0B%0B%0B%0B%0B%0B%0B%0B%0B%2B%2B%2B%2B̍B[Í$d$3D$ST$t
:tτtQuWV؋
~333ƃu%t%uu^_[3ËB:t6t:t't:tt:tt^_B[ÍB^_[ÍB^_[ÍB^_[UWVuM};v;r=CtWV;^_uAur)$`z@Ǻr$ty@$pz@$y@y@y@y@#ъFGFGr$`z@I#ъFGr$`z@#ъr$`z@IWz@Dz@Wr1كt+шuʃtt
uD$_ËD$̋L$W|$VStt9u~Ѓ3ƒtGt!ttuσ
t$u	u\"t=t)uu8˃ttu[^D$_ÈD$[^_ÉtȺ~Ѓ3‹t܄t΄t*tuĉD$[^_f3ҋD$W[^_fD$[^_;
Bu=U}tuuuuu;@]ËUVuW3}}};u|Lj^0z@TSj$hV];uQLj^0O@(C;|;r|o@v"Lj^0[_^vGEPJYEPJYEPJYK;|jv`E+EPV}MGYYu9E;VGY,E)EEPUVGYYYF SVGYY<9Et,V8GYt!EEF ȋU+]Eڙ+jjYttȃCBA$u)ttCB@$t>2M9]u#W|EPSuW~EWV}E	EpuYËUEPuuu訋]ËUEPuuu謋]ËUEPjuu葋]ËUEPuuu蕋]ËUEPjuuz]øBá -CVj^u;}ƣ -CjPpkYYCujV5 -CWkYYCujX^3ҹBC B|j^3ҹBWCt;tu1 BB|_3^词=Bt(5CYËUVuB;r"Bw+QnNY
 V1B^]ËUE}PcnEHY]ËE P1B]ËUEB;r=Bw`+P)mY]à P1B]ËUME}`QlY]à P1B]QL$+ȃYQL$+ȃYU SW3j3Y}]9]u;/uMVu;t;uo;l/PE;wMEPSuEPEBuu{;tMxEEPSYY^_[ËUEPuuuuk]̋L$WVSًt$|$u't+t/uuatt7uD$[^_tuutu[^D$_Ét~Ѓ3‹t܄t,ttuĉ3҉3t3uwD$[^_UW}3كE8t3_ËU eWj3Y}9Eud9a-xMVutu@9=-SE;wMuEuEBuuPu\ytMxE
EPj賉YY^_ËUujuuu<]QL$+#ȋ%;r
Y$-U eWjY3}_uf8c,9EtV9gYEIuuM;wEuEuuPUËUVuEPjuhAv^]ËUVuEPuuhAS^]ËUVuEPjuh.A1^]ËUVuEPuuh.A^]ËUVuWuy7v+DFt8VJV蹭V貃PyFtPfYf_^]jhBDiM3uu6*
F@t
fEPiVYeV+}O;]rOtV܄Yu}}t	3ҋu+WuV2YPZta;wM+;rP})EVPpYYt)EFKEEAEN +3uN EjhByg39ut!9ut39u;u.5+)3guHYuuuuuPEEEuYËUEtM]ËUEt8uPaY]ËUSVWuM3E苸]utec4EZcE}YYM\rՍCPbYutdeE:4EF+ƍDPVCauTVcE:tEF+ƍDPVau*VbE}Yr}_^[tE`pE3PPPPP\'jYËUSVWuM3E䋸w8uEv0nb6EdbuYYMÃM\uuՍCP
aYutbehE:wF+ƍDPVH`uRV
bE:7F+ƍDPV#`u-VaE}Yr}_^[tE`pE3PPPPPc&j	YËU$SVWuM3E܋}]t{a4EpaE}YYM|rՍF8EE]s0Da3E:aEYYMM|uaaǍ|`|`|`ePE_؃hdVSdeF])uEESvj
[0A~wII@;r[ËUQSV3҉U9Ut597vj
[0F	~w7NN@;r.;1s(NVtj
[0ENuE)^[ËUQSVuWًY{Iv	mtjtEHt"tFYPv@7UThv UT%vƙjY…uQXQMjY+twHHt,HHtHiF;tHF;ȋFr=mg;}3j^;x@rA;8ZF(;F==jdYujkdtmZ%HHtUHt*vmuFjvujZ>Yc}uSWVt#u@FPuEuMPUtBF9]w9]vE+}8]tTMapKME9]u 9]w%"9]vEy%v8]tE`p3^_[ËUujuuuuY]ËUjjuuuu:]ËUjuuuuu]jh0BW3ۉ]3};;u$3y3u;;t38;t螩E;u
$ʉ]8u $jEPhB裪PuVWEE	EVuYËUj@uu2]ËUVuu$j^0$huut3#^]ËU SW3j3Y}]9]u#ME;tVEEEPSuEPEEBcMxEEPS9tYY^_[ËUEPuuuǪ]ËUEPjuuu2]ËUEPuuuu]ËUEPjuuuu膭]ËUEPuuuuud]ËUEPjuuu{]ËUEPuuuu\]ËUEPuYY]ËUEPuYY]ËUEPuuݪ]ËUEPuu]ËUuMyE~EPhu5MH%}tMapËU=BuE
BA%]ju~YY]ËUuME~EPjuB5MH}tMapËU=BuE
BA]juYY]ËUuMtE~EPju4MH}tMapËU=BuE
BA]juYY]ËUuME~EPjuD4MH}tMapËU=BuE
BA]juYY]ËUuMvE~EPhu3MH%}tMapËU=BuE
BA%]ju~YY]ËUuME~EPju?3MH}tMapËU=BuE
BA]juYY]ËUuMqE~EPju2MH}tMapËU=BuE
BA]juYY]ËUuME~EPhu>2MH%}tMapËU=BuE
BA%]ju~YY]ËUuMlE~EPhWu1MH%W}tMapËU=BuE
BA%W]ju~YY]ËUuME~EPhu21MH%}tMapËU=BuE
BA%]ju~YY]ËUuM`E~EPj u0MH }tMapËU=BuE
BA ]juYY]ËU}]ËUE]ËUuu9YYu}_t]3@]ËUuoYu}_t]3@]ËUuu~YYu}_t]3@]ËUEPYu}_t]3@]̋V;tt+S@Nu[^̋UQUW;vlM
SEVIu;w"$SVU~u;vMU;t!t+I@NuMU+;w^[_]̋UVuW}ut_^]S]t}u[_^]ÃrNE}u+3@wEPSWSWU~,U;t#+JUUUU@uVWU~,M;t#+$UU@Iu}VSU~*M;t!+UU@Iu}I;v};sSWU~;wI};}wSWU~+u;vSVU;w2Ut#+JUUUU@u;uu;s+u;vSVUt;rI+uE;vSVUtEUʋ++;|+;sM􉄍xAM;s9u]}=;sM􉼍xAM;s}]u]EHExUEU}uuY]Vuu
u(Y3MW0uFVuj5B1Bu^9Ct@V>YtvV>Y(3_^]<1BPY<1BPYjhPBJ]]3;u9Mt339M;t3u;;t9MtډuVYeF@uoVcYttȃCBA$u)ttCB@$t!e}t:Mt2Nx
AVYEu
;ue
G}<
uEE1IËuV\YËUQeS]u3VrustnMEtR:QuMPt<:Qu7Pt&:Qu!Pt:QuE9ur.@IF@I<@I2@I(MEu
t:u
@FA;r3^[	+Uh8B1Bth(BP$1Btu]ËUuYu1BjGYjFYËV6$V;VVҪV!V(V^ËUVtЃ;ur^]ËUVu3utу;ur^]ËUMu	jX]áBt3]ËUMujX]áBt3]ËU=CthCOYt
uCY胫h2Bh2BAYYuTVWhaA2B2BY;stЃ;r=C_^thCYtjjjC3]j hpBTFjFYe3@9BBEB}5C51B֋؉]Ѕth5C֋}ԉ]܉}؃};rK\"9t;r>7֋I"5C֋5C9]u9Et]܉]ЉE؋}ԋ]E2B}2BsEtЃEE2B}2BsEtЃEE }u)BjDYu@}tjCYfEËUjju]ËUjju]jjjjjjzËU8u7Yh̋U=Bu8u6hYY]øMZf9@t3á<@@PEuf9@uރt@v39@jXhB-uEFV,YiE<+t<0|<9F3ۋuj9YÀ>:u8FVYk<E<9F<0}>:uFVקYE<9F<0}9]t]E;tjVj@wt
Gu-0u0:ËUe}SVW}%yH@Eujd[ult
B\BE+_jd_FjEÙU}[+ЉUGEim%Ek+E;Ut}}ujd[ultEB	E`B;~D?%yH@ujd[ult	4B4\Buk<M k<M$iM(}u5B
B=B_^[ÍEP5$B
(BYuDEi(By(B\&
$B\&9(B|)(B$B= B3PPPPP̋UVE3PuY9uXWS3C;Bu; B95BB
BPBPBPf95BuBVPBPRSBPVVRVBScRB
LB$PPBPNBPf95DBuHBVPJBPwSJBPVVwVFBV$TjXjYE]k}jXE
EVVVVVQRSSjYEVVVVVuwSVjYH
B$BW;};|";;~;}[^;|;;~;}3Gk<Gk<i;u
3;B3;(BVVVVV8jhB6395Bu*jm6Yu95BuBE6jL5YjhBn6j(6YeE6j5YjhB66j5Ye}EE	EP6j4YËUeVuuj^0j$hVEtӋ@ME|@Wssj^0뼃|
&AwSWjh3PQ+HF+yjd}M؋Ǚ_jh+؋EDAڙRP+jQSRP}U}M|sGEǀ3UȁEyIAu
jdYuEluAU2EȁyIAu
jdYuEluEEjSuFW%jFhRP3U}`BuBF3A9B}
A9|QIN+jFESp0jY3ShuWVjFhRP轪SUj_^ 3[^ËUVtuVYY#^]ËUEub_jX]Ë
4B3]ËUEu52jX]Ë
8B3]ËUEujX]Ë
0B3]ËUS]Vt4}v4tW}tEt1t,j^0K}tj^034B6q/@Yu3;Evj"X6uS~-_^[]ø4Bø8Bø0BøBËUE3;BtA-rHwj
X]ËB]DjY;#]u0BÃu4BÃËUVMQY0^]ËUujX]M3]ËUVuu
jXz3^]ËU|ujX]lM3]ËUVuu
FjXG3^]WVS3D$}GT$ڃD$T$D$}GT$ڃD$T$uL$D$3؋D$A؋L$T$D$ud$ȋD$r;T$wr;D$vN3ҋOu؃[^_SW3D$}GT$ڃD$T$D$}T$ڃD$T$uL$D$3D$3OyNS؋L$T$D$ud$d$r;T$wr;D$v+D$T$+D$T$Oy؃_[UQeVuuj^0Sj$hV]u{j^0y@W}`j^0WiҀyʍF3;|+B;|+ȸB;|B+EVQ`BFiȃ}uBF3B9G}B9|]JV+QFj_jElBD;FG;v}>uЋuE}urlj{CijCCtBZf1f0JuL@;v~0C@IuCCSs3ȋ{95BTM_^3[éËUjM߬Ext}@tMapÀ}tE`p3jhPBr(M}_hu3E;CWh #Y؅Fwh#SuvYYEuvh1BuFh=@BtPwY^hS=1BFp`Bj
'YeCBCBCB3E}fLCfEB@3E=}
L`B@3E=}hB@5hB1BuhB=@BtP辮YhBSE0j
%Y%u @BtS舮YeE*'Ã=CujVYC3ËUSV51BW}W֋tP֋tP֋tP֋tP֍_PE{dBt	tPփ{t
CtPփMu֋P_^[]ËUW}SV51BW֋tP֋tP֋tP֋tP֍_PE{dBt	tPփ{t
CtPփMu֋P^[_]ËUSVu3W;to=Bth;t^9uZ;t9uPuYY;t9uPƬ˫YY讬裬YY;tD9u@-P肬+Po+PaV=hBt9uP$-YY~PEdBt;t9uPY9_tG;t9uPYMuVY_^[]ËUW}t;Et4V0;t(W8jYtV>YuBtVsY^3_]jhpB#U`BFpt"~lt>pluj Y
$j#Ye5BlVYYYEEjb"Yuj1B1BUu5B2B]BËV5B2Bu5B1BV5B2B^ËUuu5B1B]BtP5B1BЃ
BBtP2B
BF!jhB"hB1BuF\Bf3G~~pƆCƆKCFh@Bj
D"Yevh1BE>j#"Y}EFluBFlvl~YEw"3Guj
 Yj YËVW<1B5BЋuNhjYYt:V5B5B1BЅtjVYY2BN	V8Y3W\1B_^ËVujY^jhBz!uF$tPYF,tPݨYF4tPϨYFtCuS~uMhTBudXu'tffGfG`t dC3PPPPPVYP;s,VhYYVXYYLlVPYYlPSP%CTlPWh>t
P;rL5B@PVWXŃ%39\tjS\)9`tjT`huduhVVVVV3M_^3[ËUB3ʼnEESWphS\PPPhxPhu3M_3[腖sHxPzYYuCHӍxPPtYYltCHphDXHAkjPd8PڐFxQtLlQP	lXCHPjPPdwp\tFdV;t6td@PH@td|-tt#PdHturjvxvPjhBjj t<3f!Ex@rh5BxP@Fpu	\FpkVBYt1hlCH輚HYXLFhdBt.p41Bu4ssTkcLYYplY3PPPPP̋UB3ʼnEESV3ۋWh;t;tPYɋDHDžpt;8L0xC&x_hXBWYY+ljp;;DžlBpPW6u6Y9ptlB~ChLBS3YY;u	;;lDWSxhP~uTlh=xxPtYtt?t
G?
39thVVVVV3xSSShxQP;t\~Ht57xP~YYtxPYu!ptC~39pu9tt3M_^3[蛑ËU}VWw$}t3GWjCYYu;3_^]WhYYu	V͗YWh YYFu6诗V詗YًBuMTYu66SVt2vp4YYt#vT66V@3
F8F8>U]jh0Be}vKH39uRNpe3GWhYY؉]܅jY}NleuMXYE}thdBu|YYt=BjYE~lSWqSFpu?`Bu67hBMYYB
(B
,B4Be.]܋u3Gj+
YËuj
YSSYYEEnËufpjhj2B3ɅB5B2B%BáBËU3M;Bt
@r3]ËB]ËUB3ʼnESVuWV3Y;ljYjYu
=B6hBhBWh"BVSf*B0BuhBSVt3PPPPPfV@Y]ËVW3(Ct~t
WW&YB|ܾB_t	~uPӃB|^[ËUE4B1B]t$j1BhYjhhB3G}39BujhڸYYu4B9tmjWYE	Ej
YËUEV4B>uP#YujBY61B^]h@d5D$l$l$+SVWB1E3PeuEEEEdËMd
Y__^[]Q̋t
O30葀OG30遀̋US]Vs35BWEE{t
N38W1Bt3%>uN@	uNhFP`1Bt,F
N@Ch5C1B3_[^ÃVWCt6;s!p~tV1B@N;r7{'YC|_^h@d5D$l$l$+SVWB1E3ʼnEPeuEEEEdËM3tUVuV
PվYYt|詃 ;u3虃@;u`3@BFuNSW^^N3_@[3^]ËU}t'VuFtVff&fY^]A@tyt$IxQPGYYu	ËUVMEM>t}^]ËUQC@VEt
{uE>'}~0EMnE>u?*u˰?X}Ճ?uE^ËUE@]ËUEAQ]ËUEf@]ËUB3ʼnES]Vu3W}uu:u++(t
`p7F@u^V[YBttȃCA$uttȃC@$q3;g
C39y
B@Dž
W@9}DžjugucDžW9~~=]VoYt
Dž51BGPPSP5HBЋtuPS5TBYYguuPS5PBYY;-uCSDž*snHHXDž'Dž2Qƅ0Dž t@tGGG@t3҉@t|sځu39}Dž9~u!ut-RPWS踷0؋9~N뽍E+Ftbt΀90tW0@?If90tu+(u BI8t@u+@t5t	ƅ-t	ƅ+tƅ Dž++u% OtPYYt.u%˰0Ostヽtu~qPjEPPOu69t.EPQYYu#P#YY|2t) Ot߃tmYtrt
`pM_^3[fÐAAAK
A
A
A
AAUEu荳芧]Ë@]jhB3u3};;uTQ39u;t܉}WavYuG@uoW~YttȃCBA$u)ttCB@$t²迦M9uu"W=uuuWUEWVE	EuvYËUuuuuh<A]ËUuuuuh`A]ËUuuuuhA]ËUujuuh<A{]ËUujuuh`A\]ËUujuuhA=]jhB3ۉ]jY]j_};= -C}TC9tE@tPIzYtE|(C P1BC4jYCGE	EjYËUSVuFȀ3ۀu@t9FW>+~,WPVBYPj.;uFyFN _Ff^[]ËUVuu	V5Y/V|YtF@tVPBYY3^]jh0B3}}j8Y}3u;5 -CC98t^@tVPVsYY3BUCHt/9UuPJYtE9}utP/Yu	E܉}F3uC4VsYYE}EtEjYjhXB39uu	V
Y'urYuuYEE	EurYjYËUQVuVEFYu	N /@t
"S3ۨt^NFFF^]u,q ;tq@;u
uYuVYFWF>HN+IN;~WPu+EM FyMttCB@ tjSSQ>#ƒt%FM3GWEPu|+E9}t	N E%_[^ËU9EuFjP;Mu+YYu3]ËE6u7[QtՉ&3@]ËUE]ËUEPEYu߃]Jx	
A
R)9YËU}t]|]ËUSU؃tP詍Yu[]ËUB3ʼnEMEVuW3|\PDž$^0l;u菬茠;t@@SurPYBttȃCA$u&ttȃC@$tuTbƅ[t4PzYt?\ttYt\PYYGP@Yu
<%k
8GX
3/THdXYcsZkƅ{(3GP辊YtdHk
DЉdN*tpFItLut{O6uG84u(8]u]FE /F<-uqtm]tfF:s{{:{s,{*ЋσdzDGJu苝L{D2ȊЋDL<]cD@b+u.du
t	ƅs\t؉l0\t؉lxt_XtZLxDžTt&HtdusDžLo.tt\SYYj0[\tYH؉ltdd}sDžLxF@xGrtt\PYY;c4cZt@3f@ƅ{l-u	ƅY+u.du
t	ƅs\te؉l(<sLxt]LptTPYLou88<Kjj
<8"I0PEYtk8<SYlTCЙH8f>D[GDd<%u8GuG\tGlD;uwPYt%\tGD;u7tlu?%uNDxnuB4lt\PYYt\lYY0uPVYlu*4u8[ut%apt
`p4[M_3^PËU9EuFjP;Mu+YYu3]ËE6u7JQ8tՉ&3@]ËUEP0|EYu߃]Jx	
A
R[(YËU}t]]ËUSU؃tP|Yu[]ËUB3ʼnEMEVuW3|`PXDž(^0l;u赛貏;t@@SurPYBttȃCA$u&ttȃC@$t85uzQƅ^t8P{YtK`ttYt`P%YYPFPb{YuPpP<%
8F
3<ƅ/T@d4ƅ]ƅ\ƅjƅsƅ_ƅkƅ{$FPyYtd@k
DЉdN*tpFItLut{N6uF84u$HLm3uF82u\dtWitRotMxtHXuAj9ht(lt
wts"F8lt{k{ksjPu3ۀkDƅsu ntPct{t`tZY`tlDP@t
d6juAct
st{u2@D4oUcdCg~Dit!njt

jd_l-ƅ\3ۃl-uX-C	l+ud`tl@udlkddtflXT0P|PCSX(q`tslPvYu]:ldd`tXl]0P|PCSX(k
lkddtfXlT0P|PCSX(j
`tllP|uYuT_let
lEIdd5Xe0P|PCSX(	`tl-u,X-0P|PCS9		l+u/ddu!d`tqllkddtfXlT0P|PCSX(`tlPtYutlt`l衺YYTjMX8QPD{HP5LB1BЃudDž@k~ƅ_tlt`lYYct4@tddv`tl=ctLsu	|	
% u4{]3ҋȃBL
3υj4_ PYt`tF!PDž? PP1ffDǃpHHt3;l<^jL;k~ƅ_F>^uFƅ]j EjPdC>]u]FE /F<-uktg]t`F:s{{:{s&{*ЋσdzDGJu{D2ȊЋD<]oDPU+u.du
t	ƅs`ty؉l0x`tW؉lxtPXtKDžTxt@tdusjo[tt`SٶYYj0[`t@؉ltdd}sjx_CDFtt`PdYY;rj8c_tD3fDƅ{l-u	ƅ\+u.du
t	ƅs`t؉l$FsxtiptdPnYou*8HLHL_jj
LH7HL<PoYtsHLSHLYlTCЙHL@tdt7`t؉ltt`S襴YY\HL؃ىHLsxt7pt2PmYou8}<58D<$tHLC{tfP^FPl<%u8FuF`t3FlP;P`Yt)`tFP;tlu>%Pxn-l~k~3fslt`lAYYDžK̋_t3f0+t`PYYt`lYY0uX)EYlu*8u8^ut>ap2u0-t
`p8[M_3^2>ËUVuWVAYtPCu	uu@Dtjj
YY;tVYPH1Bu
<1B3V]CYD0tW蓊Y3_^]jhxB胼]u[ @	x;Cr4 	~ҋ<CD0tS裿YeD0tSYElj	MEEË]SYËUVuFttv8Cf3YFF^]ËUPB3ʼnEEVuW34809}u3;u58}SCL8$$?tu'Mu׈ 輈|D8 tjjjVCVYD@l39H P41B3;`;t8?P1B4 3,9E#@?g$3
ǃx8tP4UM`8jEPKPYt:4+M3@;jDSPaC@jSDP=n3PPjMQjDQP C@1B=j,PVEP$4t1B
@089,j,PjEP$E
4t1B,08<t<u!33Ƀ
@D<t<uRD@Yf;DI8t)j
XPDYf;D80E9@8T4D83ɋD8?D49M3+4H;Ms&CA 
u0
@F@FrՋH+j(PVHP$4t1BC(8;;+4;El%?49MH@+4jH^;MsCΉ 
u0j
[f @@fƁ@rH+j(PVHP$4t1Bi(8;a+4;EGK4,9Mu,@+4jH^;Ms;,,΃
uj
[f@@fƁ@r3VVhU
QH++PPVh1B;j(P+P5P$4t1Bt(;<1BD;\,+48;E?Q(Qu448t1Bt(D8<1BD8ulDt-j^9Du݂	0?DY1$D@t48u3$蝂襂 8+0[M_3^5jhB葴]ui N	x;CrB '	$vҋ<CD0tS豷YeD0tuuSnÉ	Ձ MEEË]SYËUUVuWHFw 
yBw t;t_+^]ËUSuM7]u#B?u8]tE`pVuu$u}tE`pRExuVSMYY1+W3MQPFMQP7Ft;t+_}tMap^[ËU39Bu'9Eu艀t]9Et]Puu]ËUuM6EMA%}tMapËUjuYY]ËUhu貪YY]ËUhu蜪YY]ËUju艪YY]ËUjuvYY]ËUjucYY]ËUjuPYY]ËUju=YY]ËUju*YY]ËUhuYY]ËUhuYY]ËUjuYY]ËUjuةYY]ËUjuũYY]ËUju販YY]ËUhu蜩YY]ËUhu膩YY]ËUhWupYY]ËUhWuZYY]ËUhuDYY]ËUhu.YY]ËUj uYY]ËUj uYY]ËU츀f9E]ËUhuިYYu	f}_t]3@]ËUhu踨YYu	f}_t]3@]ËUhu蒨YYu	f}_t]3@]ËUhulYYu	f}_t]3@]ËUCS3VuE]]]F> t tjVhĬBuu~F> t>=unF> tjhȬBVu?jhЬBVƱu jhܬBV觱uF> t>ta{^ohuESuP?t3"BEMH3ɉHHHMH_^[jhB/33}jY]3u;5 -CC9t[@uHuAFwFPޫYC4V>YYC@tPVg>YYF둋}cj8&Y
C;tNhC P`1BCu43YC P1BC<}_;tg___OEZË}jڪYSVWT$D$L$URPQQhQAd5B3ĉD$d%D$0XL$,3pt;T$4t;v.4v\H{uhC"C4d_^[ËL$At3D$H3U,Uhppp>]D$T$UL$)qqq(]UVWS33333[_^]Ëj33333USVWjRhFRAQ_^[]Ul$RQt$]U eWjY3}_9Eu^x[lËEtVuEuEuEPEEBzMxE
EPjYY^ËUujuug]ËU Wj3Y3}U_9UuwkuEuEuEBPUUUËUujuh<A]ËUuuuh<Ap]ËUujuhAT]ËUuuuhA7]ËU SW3j3Y}]9]uvj}Vu;t;uvjkE;w}uEuEBuuPuUE;t5;|"MxEEPS^_[ËUujuuuh<Ay]ËUuuuuuh<Ay]ËU}uui]Vut}w
u1uuuuVh`Ayuu"i^]ËUujuuuq]ËU}uSuPi]S]VuWuu9uu3t}uuuuuu;v*8CSVh`AuGt8"uYt8PWVh`AD>u}ut8"u%tyut"h_^[]ËUujuuuu]ËUujuuuhA&y]ËUuuuuuhAy]ËUVuusgF@t FFu	VƙYFvvVYP.FFuQVѿYt0VſYt$WV踿V<C訿YY_B@$=Cu5jhXA0B3A;u
Cp<1BEu+tyt	tNt(H5C1BE;toV1BCa5C1BE;tNV1BC@5C1BE;t-V1BC5C1BE;tV1BCE}uE8]j/YÃt$t
t~~ocqj hXB3}}؋]KtjY+t"+t+tY+uC~}؅uTCCUw\YpQÃt2t!Htnb빾CCCC
CCEP1BE3}9EujN[9EtPY3Et
tuO`MԉG`u>OdMGdu,
BM܋
B
B9M}MkW\DEZ|EuwdSUY]}؃}tj臞YSUYt
tuEԉG`uEЉGd3ΟËUEC]ËUQV5C1BEu*mj^0(a WhB0BEulj^0`hBP$1Bu(l5<1BP|lY`PllYLSV1B={WhC0B;[t	uX0Bjuօuplel3_^ËUB3ʼnE}ESVW}xth|QuuP̬ub<1BzuxVVuux襬ptXFVP˙YYtHptSuuxjtjV蔙3YY;u!9ttS8%YM_^3[ÍNQSVP
u9ttS%Y3WWWWW^}uH50B3PPuu֋؅tjSYYtSPuuօu7$'Yp}fxjxPE
 Pu0BPumYYt/P41BCu=1B׉VףCE3_^[ËVjj ٗYYV1BCCujX^Ã&3^jhxBۛSeuYEE	ESËUuYH]ËV`B`BW;stЃ;r_^ËVhBhBW;stЃ;r_^ËVW30B1B0B(r_^̋UMMZf9t3]ËA<8PEu3ҹf9H‹]̋UEH<ASVq3WDt}H;r	X;r
B(;r3_^[]̋UjhBh@dPSVWB1E3PEdeEh@*tTE-@Ph@Pt:@$ЃEMd
Y_^[]ËE3ҁ9‹ËeE3Md
Y_^[]ËUE8csmu*xu$@= t=!t="t=@u3]h=u	Fd.=u	Fd=u	Fd=uFdvdjY~d`QY^`[_^]ËUcsm9Eu
uPYY]3]ËVW39=Cup5Cu5B< wt.t$<"u	3ɅP¨YtFF< wFu_^Ã=CupV5BW3u<=tGV&YtujGWYY=Btˋ5BS3V>=YXt"jSYYt?VSPuG>u5B%B'C3Y[_^5B[%B3PPPPP(X̋UEB]ËUQMS3VU9Et	]EE>"u39E"FE<tBUPFdYt}t
MEFUMt2}u t	utBe>< t<	uFN>}t	EE3C3FA>\t>"u&u}tF8"u
339EEtIt\BuUtU}u< tK<	tGt=Pt#Yt
MEFME
\YtFUFVtBUME^[t ËUS3VW9CunhCVSC0BC5B;tE8uuUEPSS}
E=?sJMsB;r6PY;t)UEPWV}EHB5B3_^[ËUSV0B3;u3wf93tf90uf90uW=1BVVV+V@PSVVE׉E;t8P膏YE;t*VVuPuSVVׅuueYuS0BE	S0B3_^[ËUBeeSWN@;t
t	УBeVEPx1Bu3u0B32B30B3EP0BE3E3;uO@u
G5B։5B^_[Ã%CËUj
ju]ËUuj
ju]ËU]U]Uj
ju']ËUuj
ju9]ËUES3VW9]u;u9]u3_^[];t};wG`j^0ET9]uҋU;uك}u+
B:t"Ou+A:tOtMu9]u;u}uMjP\Xx_j"Y̋T$L$u<:u.
t&:au%
t:Au
t:au
uҋ3Ðt:u
ttf:u
t:au
t눋U=CV5Bu3cWu95BtS[uJ5Bt@}t:uY'P֍Y;v<8=uWuP]Ztu3_^]ËD8USV3;u^j^0RCE;t9]w9]u;tWu3Y;t/WN@Y9]t ;Evj"X_^[]WuuZu3SSSSSQ̋UVW3;u^j^0ROE7;t09utSuY;tKSΌpjV3;u]][_^]SVPNJu
E;t03WWWWW)QjhB讏39Euo]lQ3?VuˌYY;tj0YeuYEE	E菏jYjhB4jY3ۉ]3};;u\j^0PujM;t	9]w	;u
9]u3@3;t;tumY;t0V舋Y@9]t!;Ev	E"Vuu蓉;u]EE̎SSSSSOjEYjhBgj!Y3u3};;u\j^0Put7E;t039u;tuY;tS̊pjV3;u[[ESVPň;u!E;t0}EEWWWWWOjnYËULB3ʼnES3VuW]ԉ]]]؉]܉u]9^F9u PF0hPESPj辈jWEjWEjWE݈jhEΈ$E9]9]v;n9]e9]\Eԉ3M܈@=|EPv1B2}(EEЃ~.8]t)E:t xM G;~8XuڋESSvPhu܉EjSv MESvWQW@PhvS$ESvWPEW@PhvS$bE}3҃}fU؉Mč_ZMMȈ~U8]tPMM:tDI҉M;(HMEfM̋M	9M~MM8YuhQPjPWEjQP$;tKP1Bu@-Pt+Pa+PSHEEEĉEEȉEЉuYouuuu3ۃCˋ;tP1BdžBdž@BdžBdž3M_^3[
PhȋAl;Bt`BQpueËUEu]]hȋAl;Bt`BQpue@gȋAl;Bt`BQpube@gȋAl;Bt`BQpuSEjP,Pj?SEjPPj@SEjPPjASEjPPPjBSEjPPjCSEjPPj(SEjPPj)SEjPPPjuEjPlPj uEjPSPhuEjP7Ph	uEjPEPPj1SEjPPj2SEjPPj3SEjPPj4SEjPPPj5SEjPPj6SEjPPj7SEjPkPj*SEjPTPPj+SEjP:Pj,SEjP#Pj-SEjPPj.SEjPPPj/SEjPPj0SEjPPjDSEjPPjESEjPPPjFSEjP|PjGSEjPePjHSEjPNPjISEjP7PPjJSEjPPjKSEjPPjLSEjPPjMSEjPPPjNSEjPPjOSjEP Pj8SEjP$Pj9SEjPyP(Pj:SEjP_,Pj;SEjPH0PjSEjP<Pj?SEjP@Pj@SEjPDPjASEjPPHPjBSEjPLPjCSEjPPPj(SEjPsTPj)Sj[ESPZPXPjuESP?\Pj uESP'`VhuESP<_^[ËUVucvvvvvv6v v$v(v,v0v4vv8v<@v@yvDqvHivLavPYvTQvXIv\Av`9vd1vh)vl!vpvtvx	v|@zodYN@@5*	@wla V$K(@,50*48<	@DH@LPTX\`^]ËUSVu~ WhBtBhdjuYYu3@IƋRtWGWUYYLJ;tP1B3_^[]28tSV<0|<9,0A8u^[<;uX@8uUVutY;BtPYF;BtPYF;BtPYF0;BtPYv4;5BtVY^]ËUSVuW3u}9~u9~u}}BejPjtYY;u3@jYj)t3YE;u	SYыu89~jtYE;u3FSuYYD8v>SjVEjPCPjVEjPCPjVEjPC0PjVEjP}PC4PjVEjPftS{YkC0|9
0@8u>;uNF>uBBCBCBC0B}C4Mu3@Mt=1BtP׋tPׅuYYEE3_^[28tSV<0|<9,0A8u^[<;uX@8uUVuF;BtPEYF;BtP3YF;BtP!YF;BtPYF;BtPYF ;BtPYF$;BtPYF8;BtPYF<;BtPYF@;BtPYFD;BtPYFH; BtPYvL;5$BtVmY^]ËUSVuW3}u}9~u9~u}}BjPjqqYY;u3@jqYE;u	SY89~4jpYE;uSuY҉8v8CPjVEjPCPjVEjPCPjVEjPCPjVEjPtPCPjVEjP]C PjPVEjPIC$PjQVEjP5C(PjVEjP!PC)PjVjEP
C*PjTVEjPC+PjUVEjPC,PjVVEjPPC-PjWVEjPC.PjRVEjPC/PjSVEjPC8PjVEjP{PCujYBE	IuKIKI0K0@4MC43@39}tM;tP1B;t#P1Bu5*YYEE3_^[PHl;
Bt
`BHpuZN(Bá0BPȋAl;Bt`BQpu,N3ËUMVWt}u?j^03AUu>tFOut+BtOuu?j"Y3_^]UV3PPPPPPPPUI
t	$uI
t	$s ^ËU3S3@9]|FVWt>EÙ+‹E<7E0fYYu
M9yNu^;]~_^3Ʌ[]ÁN0BFFËUQtP>tKhBVYYt:hBVYYujEPh w0Bt)EVYEjEPh w0Bu3Ã}u1BËU3fMf;Bt
r3@]3]ËV3 AB<w
A<wtЊ
uڋ^3
BA|Z~aw@ËU|B3ʼnEVW}CN׋jxEP%PW0Bu	!@AEPʼYYuWYtЃM_3^aUQVjEP%h 
P0Bu3);ut!}tE0WVkY;_t3@^ËU|B3ʼnESVW}@M׍0BjxEPF%PWӅuf3@cEPvĻYYjxEPF%PWӅtEP6萻YYuN~RFuOFt,PEP6Ju6N~jY;Fu!~VuWYt	V~N#;jxEPF%PWӅEP6Y3Yu0NF9^t

FH9^t<6LjY;Fu/Vj9^u49^t/EP6蜺YYuVSYYtN9^u~FЃM_^3[5U|B3ʼnEVW}pK׍jxEPF%PW0Bu!F@\EP6YYu
9Fu1Vj~u0~t*EP6ֹYYuVP?YYt
N~~FЃM_3^uv$iYj@hAF0BFuf6hv@Fhf@~YYFtjXjhAF0BFttuf6h@YFtjXjhAF0BFufËUSVWIEuO@_t8tSjhмBgt[8tVt8t	SWj@hȺBtft;t	RIt0;t+SgYj@hAG0BGugG0BGGuƃ#uP1Bjw0BEtfOffOfHfp]th50Bf9u hBj@Sdt3PPPPP^+j@Shwօt,j@C@Phwօtj
jSu݀3@3_^[]Åt3ɅD		+t3ɅD	ff;t1+t3҅DuFI+t3ɅD	3Ë;tg+t3҅DuPFQ+t3҅Du5FQ+t3҅DuFI+t3ɅD	3ËVWN;tv+t3DqB+t3DqB+t3DqB+t3t3A;BtwB+t3DkqB+t3DLqB+t3D-qB+t3t3A;BtwB+t3Dq	B	+t3Dq
B
+t3DqB+t3t3A;BtwB+t3DYq
B
+t3D:qB+t3DqB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3mA;BtwB+t3DGqB+t3D(qB+t3D	qB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3[A;BtwB+t3D5qB+t3DqB+t3DqB+t3t3    ׃$AA;BtxBq+t3DqB+t3DfqB+t3DGqB+t3t3"A;BtwB+t3DqB+t3DqB+t3DqB+t3t3A;BtwB+t3DsqB+t3DTqB+t3D5qB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3A;BtwB+t3DaqB+t3DBqB+t3D#qB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3uyA;BtiB+t3DuWqB+t3Du<qB+t3Du!AJ+t3ɅD	3u3_^ËA;BtkB+t3DuqB+t3DuqB+t3DuqB+t3t3uA;BtxBq+t3D]qB+t3D>qB+t3DqB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3qA;BtwB+t3DKqB+t3D,qB+t3D
qB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3_A;BtwB+t3D9qB+t3DqB+t3DqB+t3t3A;BtwB+t3DqB+t3DqB+t3DrqB+t3t3MAJ+=3ɅD	-A;BtwB+t3DqB+t3DqB+t3DqB+t3t3A;BtxBq+t3D}qB+t3D^qB+t3D?qB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3A;BtwB+t3DkqB+t3DLqB+t3D-qB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3A;BtwB+t3DYqB+t3D:qB+t3DqB+t3t3A;BtwB+t3DqB+t3DqB+t3DqB+t3t3mfAf;B]A;BtxBq+t3D3qB+t3DqB+t3DqB+t3t3A;BtwB+t3DqB+t3DqB+t3DlqB+t3t3GA;BtwB+t3D!qB+t3DqB+t3DqB+t3t3A;BtwB+t3DqB+t3DyqB+t3DZqB+t3t35A;BtwB+t3DqB+t3DqB+t3DqB+t3t3A;BtwB+t3DqB+t3DgqB+t3DHqB+t3t3#A;BtwB+t3DqB+t3DqB+t3DqB+t3t3qB+t3D{qB+3DVAAAAߛAAbA5AZAA٢AAњApAPA#AHAAǡAAA^A>AA6AԜAAAA[A+AAUVW}ǃHHlH!HMESj Z20;1tt0+t3ۅÍt+pY+t3ۅÍtpY+t3ۅÍtpY+t3ۅÍt3p;qtvpY+t3ۅÍtpY+t3ۅÍtpY+t3ۅÍtepY+t3ۅÍt3Bp;qtvpY+t3ۅÍtp	Y	+t3ۅÍtp
Y
+t3ۅÍtpY+t3ۅÍt3p;qtvpY+t3ۅÍtp
Y
+t3ۅÍttpY+t3ۅÍtUpY+t3ۅÍt32p;qtvYp+t3ۅÍtpY+t3ۅÍtpY+t3ۅÍtpY+t3ۅÍt3p;qtvpY+t3ۅÍtpY+t3ۅÍtdpY+t3ۅÍtEpY+t3ۅÍt3"p;qtvpY+t3ۅÍtpY+t3ۅÍtpY+t3ۅÍtpY+t3ۅÍt3p;qtjpY+t3ۅÍtuwpY+t3ۅÍtu\pY+t3ۅÍtuApY+t3ۅÍt3u"+;σ$RAP;QtiQ+t3҅tupQ+t3҅tupQ+t3҅tupQ+t3҅t3uP;QtuQ+t3҅t\pQ+t3҅t=pQ+t3҅tpQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3tP;QtuQ+t3҅tNpQ+t3҅t/pQ+t3҅tpQ+t3҅t3P;QtvQp+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3eP;QtuQ+t3҅t?pQ+t3҅t pQ+t3҅tpQ+t3҅t3P;QtmQ+t3҅Tu6pQ+t3҅TupQ+t3҅Tt@I+t3ɅD	3u3[P;QtuQ+t3҅t5pQ+t3҅tpQ+t3҅tpQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tppQ+t3҅t3MP;QtuQ+t3҅t'pQ+t3҅tpQ+t3҅tpQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tbpQ+t3҅t3?P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3P;QtvQp+t3҅tpQ+t3҅trpQ+t3҅tSpQ+t3҅t30P;QtuQ+t3҅t
pQ+t3҅tpQ+t3҅tpQ+t3҅t3I@+83ɅD	(P;QtuQ+t3҅tcpQ+t3҅tDpQ+t3҅t%pQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3{P;QtuQ+t3҅tUpQ+t3҅t6pQ+t3҅tpQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3mP;QtuQ+t3҅tGpQ+t3҅t(pQ+t3҅t	pQ+t3҅t3P;QtvQp+t3҅tQp+t3҅tQp+t3҅tQp+t3҅t3^P;QtuQ+t3҅t8pQ+t3҅tpQ+t3҅tpQ+t3҅t3fPf;QfQp+3҅TP;QtvQp+t3҅tzpQ+t3҅t[pQ+t3҅t<pQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3P;QtuQ+t3҅tlpQ+t3҅tMpQ+t3҅t.pQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3P;QtvQp+t3҅t]pQ+t3҅t>pQ+t3҅tpQ+t3҅t3P;QtuQ+t3҅tpQ+t3҅tpQ+t3҅tpQ+t3҅t3uP;QtuQ+t3҅tOpQ+t3҅t0pQ+t3҅tpQ+t3҅t3pQ+3҅TcMu+t3҅DAV+t3҅DAV+t3҅DAN+3ɅD	Mu+t3҅DudAV+t3҅DuIAN뤋Mu+t3҅Du ANxEM	g3_^]ËAcA5AA.AܳAAAATA&AAAͲAAAAFAAAAAAzAA8A
AAAAAkAUV3PPPPPPPPUI
t	$u
t$sF ^ËU$B3ʼnEESEEVWE=e=CEu}hB0B؅=$1BhBSׅ51BPhBSCPhBSCPhнBSCP֣CthBSP֣CCM51B;tG9
Ct?P5C֋؅t,t(ׅtMQjMQjPӅtEu	M 3C;Et)Pօt"ЉEtC;EtPօtuЉE5Cօtuuuu3M_^3[苾ËUVuWt}u<j^0:_^]ËMu3f݋f:tOut+f
ftOu3uf
j"Y몋UUS]VWuu9Uu3_^[]Åt}u
j^0݅u3fЋMu3fԋƒu+fft'Ou"+fftOtKuu3fy3uMjPfDJXdf 
j"YjUVuWt}u	j^0_^]ËEufߋ+fftOu3uf	j"Y뼋UMx~uB]áB
B]	]ËUEB]ËUS]u3}uA	>Vuu	W;vuMCE@uJU+2Ar
Zw ArZw Kt
ftf;t+7SVSuhPvSuo}tE`p}tMap_^[ËU=BV}u%"Mt߾9uv_u+Ar
Zw ArZw Mt
ftf;t+juuu,^]ËUS39]u3AVWu{1pjVN;tuVW<uSSSSS3_^[]ËUQQSV5B3ۉ]W;tP=(1BSSjPSS׉E;tAjP4YYE;t0uPj6SSׅt*ESPe.YYx;u3_^[Ã9]tugYV5BW3uf=tGV0YtFfuSjGWl4YYBue5B5V]0f>=Yxt"jW94YYtAVWPuI4~f>u5Bǿ%B#C3Y[_^5B衿%B3PPPPPn̋V0B3;u3^f9tf9uf9uS+ƍXWSP3Yu
V0B_[^SVW茳UEfUf;tfuf9t3]ËUSuM衻M3;u8]tE`p39]u&8]tE`p9]tV;v?E9XuuQuuR6pQuQuhpEPR ;u8]tE`p8]tMap^[ËUjuuu
]ËUS39]u3>VWu-3pVfYY;tuVW@1uSSSSS3_^[]ËUQQSV3W=Bu;te1BVVVVjPVVӉE;tTjP1YYE;tCVVuPj7VVӅt6EVP.YYy9utuLYu;u3_^[Ãu+YUMtj3X;EsT3]MVuF3wVj5B1Bu2=CtV)YuҋEt3
Mt^]ËUMS3;vj3X;Es3AMVW9]tuCYVu
YYt;s+VjS	_^[]ËUEuo	3]Åx;CrT	QދȃCD@]jhBM4339u;u	_Uj [Pj`YYu>Pm@YEPVu&PBEPW@E	E4 PjkYYËUEPuu4Q]ËUEPuu8Q]ËUEPju Q]ËUEPuu$Q]ËUEPjuQ]ËU
BU39
C#щC]áB39CËUSVu3W};u;v
E;t3{E;tvj^0VuMԶE9XfEf;v6;t;vWSVű?*48]tMap_^[;t&;w j"^08]tE`pyE;t8]t}^]ËUQC@VEt
{uE>'}~0EMnE>u?*u˰?X}Ճ?uE^ËUB3ʼnES]Vu3W}u~u+t
`paF@u^V7IYBttȃCA$uttȃC@$q3;g
C9
B@Dž
GW	@}DžjugucDžW9~~=]V2$Yt
Dž51BGPPSP5HBЋtuPS5TBYYguuPS5PBYY;-uCS*stHH[Dž'Dž5Qƅ0Dž t@tGGG@t3҉@t|s؃ځu3}Dž9~u!ut-RPWS}0؋9~N뽍E+Ftct΀90tX0@@If8tu+(u BI8t@u+@t5t	ƅ-t	ƅ+tƅ Dž++u% OtPYYt.u%˰0Otヽtu~qPjEPPu69t.EPsYYu#PEYY|2t) Ot߃t菫Yt3dt
t
`pM_^3[覤ÍIAA+AAAA%AWAUS]VuFt}^]ËUQC@VEt
{uE>'}~0EMnE>u?*u˰?X}Ճ?uE^ËUEAQ]ËUB3ʼnEES]VuWu3dH`LX[hD;u+t
`pRF@u^V;YBttȃCA$uttȃC@$q;i(u93(lxTPpEG|C8Lp`XÃ tIt5t%HHt	*9u@j
hPW轤hHQ|uL9$d;l~lŴ9j*V3Ÿ3҉p;
p
pk
ˍDЉp

*9u@WW6I"Ej[+PD=P6\L;݃CD$2M0CD$M
ʀ}u!EtȃCD M#;u~EtxuH1BjuEjPuE%Pu81B;u4<1BPȃCD 6Y6CEVSSSSSAjhBM3}39};u~{r}uj@uuEPE|EEu;t<6039}t+9}tEMCD u]YËEjjhB3}3u;;uj^0Y39};t9}tE%@tʉ}uuuuEPEEE;t3u9}t(9}tCD 6YËUQMjEPuuuutËEËUjuuuuu]ËUSuM/39]u8]tE`p3E9Xu&uuu8]Map9]u&zw8]tE`pfW};u&LI8]tE`p7VM	MEDMte9]uD]fU:u]TfEfMf;prf;pwfp1f;pr+f;pw%fpUAt	ʉMfuGDMtG9]u]XM:tfGMf;Hrf;HwfH1f;Hr+f;Hw%fHUAt	ʉMfMf;u!f;t	9]8]tE`p3^_[H8]tMapUjuuu]ËU}u3WuM}u'uuu۲}MapS]u#gd8]tE`p_Vuu$<9}tE`p2MCD8t=}u 3D8tY}tE`p3^[_Êu3
fCFD:t }u3MtfFf;uft}pH}tMap닋Ujuuu]USVWUjjhBu ]_^[]ËL$At2D$H3E{UhP(RP$R]D$T$SVWD$UPjhBd5B3PD$dD$(Xpt:|$,t;t$,v-4vL$H|uhDID_뷋L$d
_^[3d
yBuQR9QuSQ@BSQ@BL$KCkUQPXY]Y[ËUUVujXEU;u
 	}S3;|;5Cr	ƺNW<CL0u	hwN];9]t5D0$EHjYtHuШtU]]zШu<"6M;rEuY]unjjjusD(T,AHtzI
tr}tlM}CED
tPL%
tE}t?@M}ED%
u%L&
t}t@MED&
jMQuP41BxMm;MdMD}t
;
u ]EÉ]E;M<<
tCAMEH;sA8
uM
uEmEjEPjEP41Bu
<1BuE}t?DHt}
t
ML%;]u}
tjjju}
t
CE9EFD@uC+E}EKxC3@;]rK@PBtPBu
*zA;u@D1Ht%CT1|	T%Cu	T&C+ؙjRPuE+]PuSujh(1BEu4<1BP:YME;EtP|YEEE3;EL0ƅtf;
u ]EÉ]E;E
tfEM;sHf9
u
Ej
MEjEPjEP41Bu
<1Bu[}tUDHt(f}
tj
XfMLML%D&
*;]uf}
tjjjuf}
t	j
XfE9Et@u	ff+]]<1Bj^;u	0jmZe\3_[^jhB]u^ C	x;Cr7 	ҋ<CD0tƸ;E@u SYeD0tuuSE	 MEEË]SY
OtjaQYPBtjh@j腲j`̋UMPBU#U#ʉ
PB]ËUB3ʼnEE@SVW=0B3VVuEu׋ȉM;u3~Ej3Xr9D	=w؃;tPyY;t	3;tuSuuׅt VV9uuVVuujSVu1BS莊Yƍe_^[M3urËUuMuuEuuuP}tMapËU}u]uj5B0B]j$YËUuMuEMUTu}tMA#E3t3@}tMapËUjjuu]ËUjjuj]ËUjjuuh]ËUjjujP]ËUjjuu7]ËUjjuj]ËUjhuu]ËUjhuj]ËUjhuu]ËUjhuj]ËUjhuu]ËUjhujz]ËUjhWuu^]ËUjhWujC]ËUjjuu*]ËUjjuj]ËUjjuu]ËUjjuj]ËUjjuu]ËUjjuj]ËUuMrEt*xu!jjuuy}tMapÀ}tE`p3ËUjuYY]ËU9ur9w}v1ٹE"t
MMEt	e]MuE_^tMEtEM؃ىEM}tẼ`pEU[ËU3Puuu9BuhBP=]ËUjuuuu ]ËU=BjuuuuhBj]ËUjuuuu]ËUQeVEPuuTu9Et貸t
詸M^ËU}SVWuMn]u'sp}tE`putҿ9}v!;8}tE`p]ExuuVS}tAMap8+3MQP]MQPNFMtt;t+3_^[ËU39Bu09Eu褷衫]9Et}w]<Puuu]ËUSV3;uVj^0TW9]w:j^08u39]A9Mw	j"ۋM"wɋ9]t3C-N؋3u	vW0ACt;]r;]rIIG;r3_^[]U}
Eu
yjj
juuM]ËU3}
u9E}@MPuEu]ËUMEjuu]ËU3V;u1j^0/9Mv39M@9Ew	j"ӋE"wES]M9Mt-wE؉uMuuPS]؋ƒ	vW0MFAMut;MrȋM[;Mr脵j"YLNEN@E;r3^U3}
u9E
|9Es3@W}Puuuu_]ËUW}juuuu_]ËUVu~
VuYYE~PuYYttPuVuuu01B+ujX3D^]ËUMI8t@uIE+H]ËU,B3ʼnEESVW}ىE܉U~?I8t@u+}u~*΋I8t@u+u}3|e}u@Et;ujX3C;~;~jEPu1Bt~-}r}Et؊PtыM܊	:r:v8u뺅~4}r}EtPtM	:r:u8uw5(1BjjWuj	u֋؉]ԅ~@j3Xr4D;w/wątP-mYt	Ee}Suuujuօjjuuj	u֋؅tx~?j3Xr3D;wvątPlYt	3t1SWuujuօtSWuuuu01BEWn}Yue}EYe_^[M3KeËUuMfhu$Uu Muuuub}tMapËUSuM#hU3;u8]tE`p39]u&蚱藥8]tE`p9]tV;vebKEH;uEPRuu?pERuRuhQP	 ;u8]tE`p8]tMap^[ËU=Bu]juuu]jhBsp u39Eu虰薤Jdp|,>L`n~"6F\v"0@4&xhXJ<*
zn^L0
F@B@,@`A~cApB&B@{O]CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.5\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removed%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Root Key: %sOut of memoryAre you sure you want to remove
this package from your computer?Please confirmcould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfainvalid literal/length codeinvalid distance codeinvalid distance too far back`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

incorrect length checkincorrect data checkinvalid distances setinvalid literal/lengths setinvalid code -- missing end-of-blockinvalid bit length repeatinvalid code lengths settoo many length or distance symbolsinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method inflate 1.2.5 Copyright 1995-2010 Mark Adler 	

#+3;CScsI	
!1Aa 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionaryqBtqB5BhqBXqBLqB8qB(qBqB5BfFK
I*TK
ITTK
IO :i+00SBi+00@_dP/N  !:i+00'":i+00
E%6FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF΋!	Hx5i+.b`ODV	AH
FM^2mFT
d_N"
(2W]/4*&{-zeG'{-ph}OUBlOU3(9O> G e+.bchOU4^;ݧB}/NKfNr@"=3H$Oڠ'my4[J1B&M[OrG:ᠷqEJ ǬMWs5i+.bs5i+.bs5i+.bw~s5i+.b%e{HqC,40L]0RO$[Dt.+*U6F:(Y;a-kQG^)|I)sO>+dWnO@;>V;>V
Wt חb@J7<}iFϦODa'wj5Ob0wDObAGQ`{FL!mv`[c'wj5Obd'wj5Ob6J[CAVgqe'wj5Ob5i!Lz)zR88`[|^1/`[@L\J7@呰 חbu`ެ@`ެ.PRO—-T'tE`ެA`tpZdl?<W4plTI?rPB,ɨ=O${aPo0p,oiyŜ?Oɝa4Oص,OꙠς`RWpO6OyѦjc(=O0%G`묡51Mlg~6JNfsv]=D%Ocg3K@~Oq!2)wKL+2V4K@~OqT'B6Q:.7V`ƆEz5K@~OqiI~+.ͩpO]_eOkm'WFAOлP0P0P0M]`gI6FOEг]K$^5N$̈&HS3M17i;'$9Y:Oh7%9Y:Oh7&9Y:Oh7'9Y:Oh7ի|I˃(9Y:Oh7!FsGF{H@FS2IEt$#CȫR
e.{ JOe/P($IZ^9$\E9O奄`OO\;x8WFTpjzO1I(
@wiKw^ևA)!\_[C+dWnO4DLe+.bSmb`ߌ #Or'>O.jxO^QmOd4'>Or3߷;`[MOKLb`wG:J'i>VMYFDAt;&OF}Ҩ\I;%S|
*E
yЎf|txMNI{@>KJ\FЗ4mc-NvEc7VfCNItwׄ8A!ӱJ'8EK}4@VqC(DW@XzvF@S>LNdL֬+o.Eцݷ"JL
:̿,LB)隇A }jL^6CTw]+.DJQS[bHNAFPCU	.4zl'K@-tК#FlHiawhM0Y3S!AbostA^?UX2NfHyu	5ꥂG)]/qNnN9jI=W.I|Kg
4cH~%]bM
I]7BWGCQl2$HܨEye64ۅ>eL:er='oOU{p OsCů$53QB`ϝ]v+qAO;ل.CZ0YcwN]ND.Q1RWHΨ}'CBg(#l^"`G3qs03NvFZ9\;û@Z|KJ$M>MEQ wmjKDWw? ec
E
kjO}c^NIe2mG)f\"gJ]lV`W0\"F-V
pNr-O&oO}N8úGˢ)qKmHB" C[E|tKpȞ&Aõ*iG2HNOiNㄫ9O'HKlqto%yL%4FxWObDcq#	(O\iN`|\1IkLICN_3haO1FI&I}!<OGFVXia;B8n29֔hJuAtXJQxd_w~8ƏWU]O	Ɋ36(A#)V)F#Ϋ>%'GoGG+}.аvLX]p`OK #7EC)t0ō*ƾ{,D
Jև+DW^
Oor9tRNNgɆ>!OL'`g+$%|QOz)(B_@^A% xSDMt	Nn8Åm]rLwx,4Ku@+׉#G``WG 35A	AlG؂تI`FtQ<[MEĀd_NM&uf4L3lEZIC~"@0(9A8L"k1%B	T
#=E\\GNˇbR
FHspSi)!@'QL.JiFFFFFF F F!FFFF&FFF	FFk!Pi)?F0:s*Dw=F
FFF
F
FFFFFPF%FQFFFF`k;Yi+-z1OY
ȿ4<OV%
X$5I?#3:O4j;Yi+-zj;Yi+-zi;Yi+-zv nr=F>F@FDF[Fʙ^AiXשFh
Mm8gh
z0Gd<O8mxO4yO"FFFMm8gh
0F1F2F3F%F)F*F0:s*Dw=IFy.Y+F&FEFGFHF:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/Oǝv\Wސy(_FFFFFFU
8r+C+n44FâRX0eu{ڮP9Vu{0ne0E
Kvne
yOܦϫ|xOjIOQnO09$-1.E^*onePone |~|?ne?PE^#1$-?W2$-?W2$-pw~?neg@ne˳j@ne˳j@ne?W2$-~{S^BEy|KDphKΔӳOհrIOC'zO{TxhO{lhO6ǀ_`\`OOrOh7y)
Oh7BTyI6E&jnLFB}sg'Dx+h\t<6M>?i]?9A!8ҏFs%E~2]r?jdN&6u^gO!B>9}Nr*GݓkFN]ͷghhϓgAc*^Z%Ȕ2AeqKW';?B@
J$SQ`Ɔ(œO>1s-O(hHjxOiQD(ߥl+ rˆLmCBUa{Ӱ~C.`1y/DĊYF;aAdƼ403bpc(Jg
Дէ{E]E)ПS-oEH?syYz(y
K@AXGA'qQUAJ
sY!WOZ{*lg(M2(TfC'>|a. 	O;O.K[K8H]҇26 -&{-r:
%wCjW'tVamy!@iaWBVm`ɠI-`:Bn5OC(K鞟^ﯘ=ѕK0:ښL%2J4{[kYs=BMQ!B\[/B{NsASÖ.̆I#t9JDf?kјH"tŻ-Gs?zZAe!`[ǽ6NXX$KiiőԞ(LqmjKH(.~,-Y@o3\.QCpg{LKIs<_z\
LKo(t;sM|@)^vJYӞ~+IzÊChsxDpWJ?,CP0DOAoZ\q"tDk׾TLrTIkE
a`NNe76_I|kHrYM>s:
.jxOˡd:aDX7iii9P5}+EutX(T6QB~ۜC]_#ͼ_Ld=xr|խhG2`?uIp4Bf6חKt3OtaG'"v0
SNwL1"(iv@	YGح+ObC4`[ԄLr?RJ{,AsEOWL"O7v8yOhKKt&1Zs~:6B}Ftr⋪GMv2̤pDʹfD.b[GvtH;
zr\GڙYkH?FA&OA;,Ui6
IJ"x9J4ܵ;EfDװqmrE.1!YuY&HxHϣ'GVBeUNOخ|)IE@0lyדسDg,ݠeL3"5/QqCAwSk5X;-3B{_41lxpOh6ǾƱLb
VBPoz5zD #D@Fgm[M/BT|\?@zpDF[0	49Z
I}AaB}KX䌠%D|DZ#`ڽWvGE>ςZ#@k{X8&oIQd5CvSdn0@DH&'E4VwҁnB*O&-bfMlV!j

hFXapf_:qJ?򥸿2cpF^W5}3ƔHjiOY<0G==
6eFpqFwHҶe_K#q}kdO-p;z5Og5е.Í}DwMm3sG%`4n.8E40PpZdFK6eJ7`, :i+00Fh3MnMܙS{5)xKt	O3CKsw`$D&l;0MHֿRUBu(dT&arrCuƋ.|uU:WPHw[ێ	Z܊M`* !sG3^F0MJSkyZ
8y
M3,/KqI\M;TQ'CHCh4-6C$/`zLbeLWwR"!5C34a@Y?JTwZ8KMn錕Ra/pam/pmCorExitProcessmscoree.dllB0BTZSunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunHH:mm:ssdddd, MMMM dd, yyyyMM/dd/yyPMAMDecemberNovemberOctoberSeptemberAugustJulyJuneAprilMarchFebruaryJanuaryDecNovOctSepAugJulJunMayAprMarFebJanSaturdayFridayThursdayWednesdayTuesdayMondaySundaySatFriThuWedTueMonSunKERNEL32.DLLFlsFreeFlsSetValueFlsGetValueFlsAllocLC_TIMELC_NUMERICLC_MONETARYLC_CTYPELC_COLLATELC_ALLlB@`BdBATBdBtoAHBdB0A?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;runtime error 

TLOSS error

SING error

DOMAIN error

R6033

- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.

R6032

- not enough space for locale information

R6031

- Attempt to initialize the CRT more than once.
This indicates a bug in your application.

R6030

- CRT not initialized

R6028

- unable to initialize heap

R6027

- not enough space for lowio initialization

R6026

- not enough space for stdio initialization

R6025

- pure virtual function call

R6024

- not enough space for _onexit/atexit table

R6019

- unable to open console device

R6018

- unexpected heap error

R6017

- unexpected multithread lock error

R6016

- not enough space for thread data

R6010

- abort() has been called

R6009

- not enough space for environment

R6008

- not enough space for arguments

R6002

- floating point support not loaded

B(B	ЩB
B0BШBB0BBpBBB@BB8B ФB!BxByBzB|B\BMicrosoft Visual C++ Runtime Library

...<program name unknown>Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODESystemFunction036ADVAPI32.DLL	         (((((                  H          h((((                  H                                 H	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~united-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamericanBENUBENUBENUBENABNLBtBENCpBZHHlBZHIdBCHSPBZHHJdp|,>L`n~"6F\v"0@4&xhXJ<*
zn^L0
PropertySheetACreatePropertySheetPageACOMCTL32.dllsSetLastError|CreateDirectoryAGetFileAttributesAWMapViewOfFileCreateFileMappingARCloseHandlejSetFileTimeDosDateTimeToFileTimeGetLastErrorCreateFileAUnmapViewOfFileMlstrlenAgMultiByteToWideCharEGetProcAddress<LoadLibraryADeleteFileAReadFilefSetFilePointerGetFileSizebFreeLibrarySetStdHandledGetStdHandleHLocalFree]FormatMessageAGetTempFileNameAGetTempPathAGetModuleHandleAGetVersionExAResumeThread}SetPriorityClassGetCurrentProcessGetCurrentThreadSetThreadPriorityCreateProcessAGetModuleFileNameARemoveDirectoryA;GetPrivateProfileIntAAGetPrivateProfileStringAGetModuleFileNameWKERNEL32.dllMessageBoxA,GetFocus2wsprintfASetDlgItemTextAwSendMessageAeReleaseDC!GetDCDispatchMessageATranslateMessage2PeekMessageAEndPaint~GetSystemMetricsBeginPaintDefWindowProcAUpdateWindowShowWindowmCreateWindowExAKRegisterClassALoadCursorAMoveWindowGetWindowRect5PostMessageAdGetParentrSendDlgItemMessageA'GetDlgItemSetCursorUSER32.dll6CreateDIBitmapDeleteObjectSetTextColorTextOutASetBkModewSelectObject<CreateFontATCreateSolidBrushGDI32.dlllRegQueryValueA0RegCloseKeymRegQueryValueExANRegEnumKeyExA`RegOpenKeyExA}RegSetValueExA8RegCreateKeyExA=RegDeleteKeyAGRegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dlllCoUninitializeCoCreateInstance>CoInitializeole32.dllyGetSystemTimeAsFileTimeHeapFreeHeapAlloc%FileTimeToSystemTime$FileTimeToLocalFileTimeGetFileInformationByHandlePeekNamedPipeGetFileTypeEnterCriticalSection9LeaveCriticalSectionGetTimeFormatAGetDateFormatAHeapReAllocGetModuleHandleWExitProcessDecodePointerGetCommandLineAHeapSetInformationcGetStartupInfoWIsProcessorFeaturePresentTerminateProcessUnhandledExceptionFilterSetUnhandledExceptionFilterIsDebuggerPresentEncodePointerWideCharToMultiByteGetTimeZoneInformationrGetCPInfoInterlockedIncrementInterlockedDecrementhGetACP7GetOEMCP
IsValidCodePageTlsAllocTlsGetValueTlsSetValueTlsFreeGetCurrentThreadIdHeapCreateHeapDestroy%WriteFileWSetEnvironmentVariableWVSetEnvironmentVariableASleepInitializeCriticalSectionAndSpinCountDeleteCriticalSection FatalAppExitAoSetHandleCountGetConsoleCPGetConsoleModeRtlUnwind-SetConsoleCtrlHandlerInterlockedExchange?LoadLibraryWGetLocaleInfoWaFreeEnvironmentStringsWGetEnvironmentStringsWQueryPerformanceCounterGetTickCountGetCurrentProcessId-LCMapStringWiGetStringTypeWGetUserDefaultLCIDGetLocaleInfoA
EnumSystemLocalesAIsValidLocaleWFlushFileBuffers$WriteConsoleWHeapSizedCompareStringWCreateFileWSSetEndOfFileJGetProcessHeap5B5B5B5B5B5B4B4B4B5B5B4B5B4B5B5B4B4B4B5BSoftware\Microsoft\Windows\CurrentVersion\Uninstall4B4B4B|4Bd4BL4B<4B$4B4B4B3B@3B@3B@3BC@3BC@3BA@Software\Microsoft\Windows\CurrentVersion\UninstallN@D C CpPSTPDT@BB
		


!
5A
CPR
S
WYl
m pr	

	
)

                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@B`y!@~ڣ @ڣ AϢ[@~QQ^ _j21~CBBBܠBؠBԠBРBȠBBBBBBBBBB|BxBtBpBlBhBdB`B\BTBHB@B8BxB0B(B BBBBBBBB̟BB	BBBBBBBxBhBXBDB0B BBBBBBBܞBԞB̞BĞBBBBBB|BpBBdBXBHB4B$BBBBB؝BBBdBdBdBdBdBBB@BBhBBB@BB
`BPBBBBBBBBBBB;Zx0Nm:Yw/Ml..BCCCCCCCCCBCCCCCCCBBB. (@pnklmn	(	8	H	X	hx1
; =$?ZABZ(n,	BBB999111)))cR[RABZRYRZRAB[R[RAB[RAAB[ && &&&@JQ1AA1ZQ1111ZQ1AAZ@JQ1AAZQ1AAJ eu eu @ABZ@J@G@F@F@G@AABX@J@AABX@J@J@AA1X@J@G@HRX@G@AAG@ZRX@AAG@JQJed%ed%ed@AA1ZQ1AA1X@J@HQ1AA1X@1A1ZQ1AA1ZQ1A1J  & & RAABZRABZR[R[RABZRYRBZRABZRBW@J@J &R[R[R[R[R[RABZR[R[R[ & & & & & & &@J@J@J@J@HQ1AA1X@J@J@J@J@J@J@G@J@G@JQJ@ABZQ11Z@J@AAG@J@G@GQ1J@AA1ZQ1YQ1[@J@AAG@J@G@1W@J&@I@G@J@J@J@J@G@J@G@Z@J@AA1X@J@HRABX@J@HQ1AA1X@J@J  &  %& & & &RAABZR[RZRAAABZR[R[RABZR[R[@H{SetupMS Sans SerifP}
This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.P}PhnP}@H{SetupMS Sans SerifP}
Select python installation to use:PP}7Python Directory:P}jPhnPP}BInstallation Directory:@B2Find other ...@H{SetupMS Sans SerifP}
Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.P}msctls_progress32Progress1P}Installation progress:PhnPA@H{SetupMS Sans SerifP}
Click the Finish button to exit the Setup wizard.PhnP}(
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/wininst-14.0-amd64.exe0000644000175100001730000217400014467657412025167 0ustar00runnerdockerMZ@ 	!L!This program cannot be run in DOS mode.

$%KKK|kK|k`K|kKVWKHKNKOKKKKJfK_CKZK_IKRichKPEd *PX"pȗ@p	`d@	XZ`	lT.text `.rdata*@@.dataKl@.pdataZ\|@@.gfidst0	@@.rsrcX@	@@.relocl`	
@BHtt
+|>+B|.PK8t33ۉ\$@fB;\.LcLMcF*A8LcLA>PKuA<$PKuAF.AN LcAFLID$HcHT$DIT$HIHHHHD$`H	DpHuHL$pHHT$pHL$PHH8u<\tHL$pHH8ufHL$psHcHD$pHHD$XE3HD$H2HIIF8uIUE3҅HHHHD$HL9uMD$HL$pIH\$PHD$p8t8/u\HuHL$pHH<u<\H\$Xt_ENHvHD$0HT$pAFLfD$(3AFfD$ Ht'ANED$ENHT$`L$ HD|$@HFD.AED|$@BD.D;T$D3HT$HHIMHIF8uHL$pHHD8uLD3AH„uED$HL$pIcIIE+HD8uH\$P<\t </tHL$pHHD8uf:\t:/uHAMcHL$p@HH3zL$I[8Is@I{HIA_A^A]A\]HEHEH\$Ht$WH0IHHE3H\$ LHHŞH\$@Ht$HH0_HHPL@LH SVWH0HHpHE3Ht$ LHHyH0_^[H\$Ht$WH0IHHKLLHHHD$`HHD$(Hd$ >H\$@Ht$HHH0_H\$Hl$Ht$WH0IIHHH\$(LHd$ LHHHߣH\$@Hl$HHt$PHH0_H\$Ht$WH0IHHH\$(LHd$ HLHHHHt$HHH\$@H0_HHPL@LH SVWH0HHpH+LHt$(Hd$ HLHHHHH0_^[LD$LL$ SUVWH8IHl$xHHHl$(LHd$ LHHHˢHH8_^][H\$Ht$WH0IHHH\$(LHd$ IHHH\$@Ht$HH0_HHPL@LH SVWH0HHpH7Ht$(LHd$ IHHfH0_^[/H\$Hl$WH AHHHtwtnviH\uU80|W83~#8nt
8ruHH
;f
HH/AHT$0HQ<
u
HHD$0HHuHl$@H\$8H _@SH HH
HtH6%HH [HݎHuHH\$WH HٹY9HHH
H\$0HOHH=H _H\$Hl$ VWAVHHXdH3H$Hf3E3LH@AHuH
AE3HHD$ DBHH
qH!|$ E3DB*H53HۃLH׏HL$0HL$0AօtLDKcHޏHL$0HT$0H
Hd$ LcDBLH
ƞHvHrH$H3qtL$I[0Ik8IA^_^H\$Hl$Ht$WH0HHHÀ<ud$(DKHd$ L33Hɋ7HHu3+l$(DKLH|$ 33vu
HbHH\$@Hl$HHt$PH0_HHXHhHpHx ATAVAWH DHHPHHH=HHH*HHHHHLHHL3H9
u3GHt?Ht:Ht5Mt0Mt+Ht&EH
UAI2ՋH\$@Hl$HHt$PH|$XH A_A^A\H(HLD$@Hu3HT$@H
H(H(HLD$@Hu3HT$@TH
әH(H\$WHPH`H3H$@H=HuBH
IHuH
_H@JHFHHLD$ HHH=t3H=kHT$ H行tH
rH
HGHkHcHE33DHT$01tHT$0H
}˘H
HLD$ 3H$@H3qH$`HP_H\$UH$@HH_H3HHd$h3Hd$pHڃd$XHd$xHd$PHd$`yHMH
DHD$XHHD$@LMHD$pHD$8LEHD$xHD$0H(HD$hHD$(HEHD$ wu3HD$PDHD$ L
3H
TyH_HL$PLD$`HCHyH9HL$PHUHyHHL$PHUHP8yHHT$hHtHL$PHPXyHHT$pHt#HL$PDD$XHyHHT$xHtHL$PHPHyHیLEHED$(A3HD$ 3HL$`HUDHP0yFLEHH
;D*HL$`HtHPHL$PHtHPdHL$`HPHL$PHPòH
ֈHH3_nH$H]LHHIKHIKMK HMCH<bu3-DL$`HLD$hHT$0̱H
HHH
hH%*H\$UH$@HH|\H3HLKD$0H,HOHHHHD
ÔHD͓HHL$@HD$ LL$0HLEHT$@t#LL$0HLEHT$@t3GHMHH9uFfHMHH9u3ҊH„u3HMDBHH3lH$H]H\$UVWATAUAVAWH HIH0HQHHHVHL
H[HHHXHLHUHHHD$h̫HUHLHRHL3HD$pHHMMHMMH
HHt[HHHHHH-fHґHHc3HHAHLHAHv rHl$hHD$pHx3H-L5XL=yH\$`H A_A^A]A\_^]@UVWATAUAVAWHpHl$ HHYH3HEHHMHŅHtHMHHE`HمHLMHHL:HHL'HxHHHHHEHHHE3H9MMMMHwH9MmHdH9MZHJ8BH
u"HJHHXLFH
LbUHHm3HAL+HI>Ht3HHHGH;|HӹAH0HHtHHH;|HUλ)uUDE,A@HcHAH;w
HH蘔H+H|$ H~HcH:
Hc:AՋAԋHMHH3thHHePA_A^A]A\_^]H\$T$UVWATAUAVAWH@I!L33IM͂Hd$0E3D$(DźD$ HL<H؋ܨLΨHӋH$HӹuHHtMIHHϋw#
HHqIչ&H$3H ;s
3HGHc*E3HHtCE3D$E33HHL$DL|$ H$HD<HIH$H@A_A^A]A\_^]HHXHhHpHx ATAVAWH LLHDHIL1HIHHIHHTIHHMt;Ht6Ht1Ht,Ht'H
uAItIՋ؅t׋H\$@Hl$HHt$PH|$XH A_A^A\HHXHhHpHx ATAVAWHHiTH3H$H=332Hd$0E3D$(HD$ LEAH@L0H֋LH֋ߤJHHu-dDH*HL$PHL$PHH.HˋI׹IԹs3HxDG-Hc(HHtdd$@H̄H+Š
H„uE3E33HԣHd$ HS,LL$@DHQD$@H˃,HH
HGIH$H3cL$I[ Ik(Is0I{8IA_A^A\H\$WH`H|RH3H$P3HtEHD$0DD$(DHD$@3ҹHD$ mHT$@HL$PD蛜HL$@(D$PHL$PHcLH+HD$PHHJH
LAHT$P3H$PH3cH$xH`_LISMCMK SVWH@HQH3H$0HIsHt$(HT$0Hd$ LAHH躍tot%H
HH!E3H
pHc^DI9L$hLH
GQHT$0%A0LɂHHT$0yH
FHtHrL$h
H$h.sHtBHwHGu/H$h~ H
HtL$hHH$0H3?aH@_^[HHXHpHPWH@H`H
ԉE3@@EA4HHu3lHT$XHHd$(E3Ƀd$ 3HˋEAHHHtHd$ E3E3HAQHHHÉ5H\$PHt$`H@_H\$WH0H=HtQH=uGLHȃd$(HEH
IPMHT$ ACHHH^pH\$@H0_HHXHhHpHx AVH`HNH3H$PH
3C+T
+T"H-HcHH-ޙ|PK!;{V4tHq3LcCEtHcCHH+I+H
LsA+A+ЉuIcH+"HHHT$@LH'E3HL$@tnEE3Hl$0Hfl$(fl$ AHxHHtYMcHHHH@8,uHKH譋HHH5ИڟşH3H$PH3U^L$`I[IkIs I{(IA^HhHL$0HL$0E3D$ E3HL$03%uHh@SUVWAVHHLH3H$HtHT$p.H^E3E3ȸgfffH~HD$hD҃d$`3҃d$Xd$Pd$Hd$@d$8d$0AAʉ\$(AD$ HH`HHrHL5HHA<uL$ DMH:H$HA<u
\$ DMH
HHHHT$pH'3H$H3\HA^_^][HHXHpHxLx UH8/H+HKH3HHPD$`3HD$h3Ht$pHu3HD$xHE[L=\}HuHL$`HEL}şfuH
iLJ}E3HP}L[H\}HMj3*HL?Ht$XLEH\$PE3Ht$HIHt$@3ɉ|$8D$0t$(t$ AHȺHHoHHH3%[L$I[IsI{ M{(I]H\$WHPHIH3HD$@HT$0Hq3DT$0ȋD$4D\$LD$`HzHM(HD$PAE3HD$ HUHu{D$DHHtVHL$PHD$DHD$(E3E3H\$ 3u0LME3ILHLcIHL$PHd$8Hd$0Hd$(Hd$ HL$HLL$@LD$`HL$HWHMPH3vWL$`I[0Is8IA^_]H\$WH0HD$@AE3HD$ HHRH3ۋuHL$@ËH\$HH0_@SH HQHH;tKH=uu:HQ1ALlyHmyVHHHH
QH [̋
}~HVPu=}HEP}H|RHl$H|$Ld$ AUAVAWPH+HDH3H$@HNt+fD;IfD;3HF}HtE3HD$ ArЙHϋHH]HƙHHCHd$ E3AH}LHvHd$ HLcAHϋU|t8L|HxH$@L$@H!|EuGt&Ls|H,xH$@H$@HUxALxxHHAE3HEϺpTHd$ E3AHIHLA;u\EOE3HȺpLnHSLnH>n{DvIME3HȺpHd$ AMcMHL-{IH+HH
NHuMźHHd$ MAHHcLHtgMHD$ AHkL
zILyHwu"D
zHwDyH
MuIym1utL3B*L0H„uHD$0IB<0uHD$0A|\tHL$0HH9u%mfHL$0HH9uM@3AH„uLD$0HYAy8uOHd$ E3ɺAeIHA;uENwAE3pH3H$@H3RL$PIk(I{0Mc8IA_A^A]HHXHxL`Lh UAVAWHXHH@H3HH
LHuHHuL=vLHDIHd$@HD$`HD$8E3Hd$0E3D$(d$ XtEu$HjuE3HEH3ՔE3LuHIL% xL-xMMHuHL$pHuHL$pHjxHu9LLD$pHjuHzPHRHL$XjHL$XHL$XLLluHL$p
H
wHT$pH
wLyHguH
wHduLwHguD
vHMĉD$ HL$`HD$PHD$@HHD$hE3HD$8E3Hd$0D$(d$ t \E3L
uHHzHL$`oAD9t$PuH
wLMHtD
vHvDuHtHL$pHD$ HHL$pHH<uHL$hHtAEΉD$(E3HD$pHHD$ tE3LtHHT$pH
`vHD$pHD$(LMH\$ HxtMHtMHL$p`HtHL$pKHcrLH
zuMH;HMLd$(MLl$ HHtHL$p
HD$pHǀ<8uHL$hHD$pAHLt|$(HEHD$ E3tE3LsHHT$p‘HL$pMHL$(LH
WuHsH\$ &AHH3ML$I[ I{(Mc0Mk8IA_A^]HXHB<H3H$@HL$ 5HL$ 蛽HL$ 葽LLsHL$0H
tHT$0H
tHt:H$@H3MHX@UVW@xH+H;H3H$0IHNtxt4Hd$ MDBLƺHHt$ E3DBw>H$0H3]LH@_^]HsHtE3HD$ Ar-L&sHrHL$0ԏLD$0H	LrHAy1t0Ay8AE3HȺpbH=u$sƏE3E3HȺp2HE3E3HȺkuHLrHHA<uB|\tIHH9uefHA<uHHNHB-^H
WrHHt9tLqHӎ=GrLqHH?uH
qK=r=kqtKLqHoH
tLqVqHHt3HwH=qtW=fntNLqHH
3tLqHHtHH3ZJHHpLpLx UHhHpH^8H3HE`HNu=p=lHd$HHqL%qHD$@=3HpDPHuHL$PHH9uqqfAHL$PHH9uL l3AH„uH
IpHtLL$PLjHp3?HLLL$0HD$PLD$8HD$8HL$PDtHHpELt$0MtMƺH?LpH*I袸I)|eH[oHtE3HD$ Ar=fou#H`LbHHLEE3E3HU)Ay8uAE3HȺp'3HM`H3iGL$pIsMs M{(I]H\$UHl$H H5H3HEHnHL$$3DBd_HeHM33HEHEHED@`_3D$ hD$$gHd$PHL$ HD$(H`HD$HHD$0kąHL$ D$$HEH4HD$HHD$0lHL$ D$$HEHlHD$HHD$0mlHL$ D$$HEHHD$HHD$0n@3E`HEHeHMHeeHEHEHEH]E EHMH3EH$0H ]H(H
b_Hu3H(HdnH[Hd^HtH(HHH:4H3H$=lu3RLlHgHL$@	HD$0AE3HD$ HT$@HuHL$0H$H3EHĨHH3H3H$D$(L
2_Hd$ LmHm3 /DH}mHL$0ZALmHT$03PH$H3pDHH\$Hl$AV@"pH+H3H3H$0H~~L5^HD$(H-7mLL$0MƉ\$ HH$m
APHT$0H
jH,~LL$0HD$(HlMƉ\$ H˃DHT$0H
mH}L
mHD$(HlMD$ PHL
}HlAHdL
}HlA:jHAgHjHu}MHD$(H~lLD$ 
HHK}L
iHD$(H`lMD$ PH
VlH}L
fHD$(HFlMD$ HH|L
iHD$(H(lMD$ 
HHHÀ;u\HlH
huuuuLHkH
htu[uKtBˀ=ht7HkH
}htt E3LkHHkKHXisH
hH
{HtTH
hHt3H$0H3AL$@I[IkIA^HHH+Њ:u
Hu3H\$UH$HH/H3HAHU3LEHjHHjHHjHH4LEHHj!LEHHjLHHjHhHL$pD3YHD$P\$pHD$HH3EHD$pf]HD$@E3HZE3HD$83H\$0D$(D\$ 
tUHL$XSHȍSqHȺHL$PHL$XWHL$XHH3?H$ H]H\$Hl$Ht$ WH0Hl[HHPHH]HHPHH
HHPHtH
B:HD$HAHD$ E3HW}tE3LycHH͂=HL$HHS}twE3LiHHHL$H}H>H\$@Hl$PHt$XH0_H\$Hl$Ht$ WH0Hk[HHOHH]HHOHH=HHOHH
59HWAHD$HE3HD$ |tE3LibHH=HL$HHS|tgE3LhHHHL$H~|H.H\$@Hl$PHt$XH0_@SH :NHHuH [H׷uHH [H%}@SH :NHHuH [H蛷uHH [H%|H\$Ht$WHPH+H3HD$@[`NHu3HH]FNHHtHH5UHH+HDA+uHEuHd$8HfHd$ LL$ LD$(HD$0HH\$(tHHfH|$ Ht!?tE3LfHHH褬H+HÄuHL$@H3;H\$hHt$pHP_HHXHpHx UATAUAVAWHx`gH+Hu*H3HPE3HT$@3Dt$0!t$43LEn
tHCfHJ:JfA:$ t	A$H~H~Hj~IG AAE+AH+EoD+AD+EgHGEVDIAI@IG#AF@H(A_A^A]A\_^][E3HtfHQ(Ht]DBDADALA BtALHHHHB`HBX3LDBBLB LB@ǂø3HtHA(HtHP,P4pH\$Hl$Ht$WH HHtXHy(HtOy3ƃ0}tCw*HW8Ht9_(tHI@U8Hg8H͉w_(hH\$0Hl$8Ht$@H _H\$Ht$WH HMA81AXHuA~Ha Hy0uHa@Hy"HA0Hy8uHs"HA8HI@AS0HHuG1H{(H`8HtHK@HS8Hc(H\$0Ht$8H _ELº$EHtJLI(MtAy
Aa@AaD3Ã+EADEA wEQDAA#AA@͸HiqAh	HAXHWyHA`AlHHXHhHpHx AVH HY(E3AHHL9s8u!K(DHH@P0HC8HuD9s,uK({,Ls0{,;rHK8H+HDPDs4C,R+{4H֋K4;GHK8DH+O+tHK8DI+HOk4{4C4;C,ADƉC4C0;C,sljC03H\$0Hl$8Ht$@H|$HH A^@USVWATAUAVAWHHXHy(3LHH9QH9u	9Q?uDQELYL	DiDw@wDL]LMDUHDmDUPUH_lLh	;-TtC\HXA_A^A]A\_^[]ø;s&EAIDLMA̓rDwAtHyAtHyHO HtAGt'OHUXDuXAADuYLM3҉GD!ExAIDLMA̓ rHG HtDpGt5OHUXADuXAEYAAEZDu[G3LMD!EAIDLMA̓;rHO HtAƉAAHG HGt#OHUXDuXAADuYG3LMDGHG HtHPLMG_HA;AG݅HG HLHMP+WHH;vp+nEAIDLMA̓;rHG DwHHtDpGt#OHUXDuXAADuYG3D=L}DIIK3L}GtMuODIb3҉GLMD+L)_HLM9WH:WHGEڋF<HG HtHP HtOH;H(sD<GH3EtA;rGt MuODILM3҉GD+LLMEtMHG HtHP WHGEuڋF<HG HtHP0HtOH;H8sD<GH3EtA;rGMkx9Wu,pEAIDLMA̓;rGtEAunLMDEPDUHL]ID$ sHHOlDGxLHG`GtHDL|$(HL$ HG
3҉E؅t	HmLMLhDEPH_lDUHL]AruArlM\$AET$IM$El$Dw@wD?M\$M$ET$El$BDw@wDDEPL]DUHLMAL_XHAH#A;EAIADLMA̓HAH#HGX;wDAAE‹AȉE`AAAE#ADCDADD;viL}EADMaAIDEbAAAAL}E#AADHGXBDED;wLhMaA+3҉+AOHu t@tH=jLMȃOPWPtC!EAIDLMA̓;rۋʸ+A#AGHGH3҉L_`HAH#A:EAIDLMA̓HAH#HG`;wDAAE‹AȉE`AAAE#ADCDADD;veL}EADMaAIDEbAAAAL}E#AADHG`BDED;wMaA+LMLhDEPDUHL]+A@tHXhOLȃOPWPtO-H$igEAIDLMA̓;rۋʸ+A#AGL3EZOLAA+;+;O09HgZtWt.9W!EAIDLMA̓ rE+ED$DGEt?9WIAtH+u#OOH+L]3DUHLMGAD$LADUPAEA%A9WAE;OtH\hPD9W9W
!EAIDLMA̓ rD;wHhEGHAIAL]DUHG4;v	W,+++HW8GH;v
	GHIH+ыA;AGD++DUHI+ӉGHBAIÃu3L]A9WHM\$ET$M$El$Dw@wDEL}DEL}3HE]PID$EHAD$M<$El$Dw@wD9W,uA;\$t+?&IT$DE+D$Iy3҅tA+\$A\$EA+D$AD$_9Wt>t:9WIT$tH+uODIOH+De3҉GAD$L?t?DuAGظɃ@?DЋEAѹWDAT$HD@SH HA(HHt-LA8Mt$HP8HtHI@AHS(HK@S8Hc(3H [H\$Ht$WH IHHtMHY(HtDC0t/Ht*S4H+HS8D8DC4K0HS8I+H8HtC03H\$0Ht$8H _H\$Hl$Ht$WH AHHHtHY(Ht{t;
tH\$0Hl$8Ht$@H _Ã;
uDƹ;CtH.DHt
C3HtHA(Ht@tHP b@3øD	E3LEttQVDE3f@+щVDr"DN@F@ABD0ADN@sVDHN|!HT$0HHN|DGG)GDWH~|t#DOHDW3DOH\$8Ht$@H _3HtHI(Ht9
u9ADuøH\$Hl$Ht$WAVAWH HHHHHz(HHB0HHz8HK@AAAHHu
E3L9w8t&O(AEHK@S0LHuHK@HS87HHEKDBIMC E K0M0C@E@KPMPHI@ A H0I0@@A@HPIP@`A`IHpIII+uHHI@ A H0I0@@A@HPIPH@`HA`HHHOXH;rAHH;w5H+H+HHRHHFXHG`H+H+HHRHHF`HH+H+HHRHHMtO(HW8AIET4Lv83Hu(H\$@Hl$HHt$PH A_A^_HtHA(Htǀø3Ht-HA(Ht$8uPH8u	+PHøH\$UVWATAUAVAWHl$HHH3HEL}HHUM3ELEwLMD҉MDbLEL}AHH EfTAvAEtHIIfDdEI+uA8MAAf9TEuDE;sA;AGEuHD$ @D$ IMIEM+uE 3HMH3H$HA_A^A]A\_^]EE;vHEf9uEIE;rA;AEABALE+0EAvE3҅~E;fDUIʺD
fD
fD
II+u3Et+Hf9tLEfEOfDdE3EIE;rE3ۅtBA;tH5e[AHuH\5H[H+H5~[H+AHuIL}IAIEAD\$$ED\$(AHEAMEHUD]ACEu	ATwA;uAPv
pDd$(AA*ĈD$!HMAA;}
3fL$"D$ ~
ND$ JD$ `3fD$"D$ ALmA+̾D]AA+ADD+uLmAHASuE3ۅt	B#AۋL$$AL$$fTEu E;HMAHEDHL$$D]HUHuD;DeD#D;eD\$(AHMEۋEDDA+D\$(DHHME;sBL]+х~AE;rLmEAAED]u
AT{A;u
APiIEHUDeB4IEHuB|IMHEH+HfBDL$$%C%xD%bD%dDffH;
uHfuH7@SH H3AHA@HȺ	H [H%AHL$H8't)H
HD$8HjHD$8HHHSHHD$@H	HkH
HHkH
HL HkH
HL H
tH8H(H(̉L$H(&tD$0)H
HD$(HHD$(HHHkH	HkH
T$0HH
_sNH(LD$T$L$H8M&tD$@)H
HD$8HHD$8HHmHH7	|$HvH|$PuD$H|$Hv
D$HȉD$HD$HHkH
T$@HD$ 
D$ D$ D$H9D$ s"D$ L$ HLD$PIHH
Pr?H8H\$ WH@H>HHT$PHE3>Ht2Hd$8HL$XHT$PLHL$0LHL$`HL$(3H\$ r>H\$hH@_@SVWH@HC>H3E3HT$`H1>Ht9Hd$8HL$hHT$`LHL$0LHL$pHL$(3H\$ >ǃ|H@_^[@SH SH;tl
H
J
uVXtH
tD	3H [ù1̹&H(3H(H(	H(H(H(H\$WH0u@2@|$ l؋
u
uJH?H
a?t
H??H
(?q@@|$ #HH8t"HjtHH	E3AP3HH8tH:tH61LD3H
hNuG@u3ұ!%ù|$ uH\$@H0_H(H(S@SH ELH
GhD3H [4H(H(2HHыH3ƒ?HLHAй@?+HI3HHLcAOL*OHHtHHӋHӋH\$0Ht$8H _H\$Hl$Ht$WH AL
NLNHHNHHtHaDŋHH6H\$0Hl$8Ht$@H _HE3¹@?E+HIH
L3H;HHу	ILH@L;ūu9SH HlHHtHt8H#HHiH;uH [H@ƒ?+3HH3LHAй@?+HI3H@ƒ?+3HH3HFH!HH\$Ht$WH H!HAAaHHH:E3LA	@:tAA<;wI?IrA<v~vt5IAAH8uHmHtHH@:t&H#CC{uC
AAHt$8HH\$0H _ḦT$SH H!HAatAHT$8HH [H\$Ht$WH 3HHHtHE3VH
;@HtH
ZHOHFHxHHH$C@qH1cHH\$0Ht$8H _@SH H3ɈKcHHt!HD8
tHA8uEtHHH [H\$WH aB3HDOH;;DGDC;ukHHuCHH\$0H _H!HAa@SH@H+H3HD$8E3LL$5DYLaHLED\$5HyAIIHIHD*A0ELHuEtIA-LD$5IE+HHHL$8H3H@[@SH@HH3HD$8E3LL$4DQLaHLDT$4IHIHD*A0ELHuLD$4IE+HHHL$8H3CH@[HWHHHeXQH3D@ADAH̃	HAHAXDDL{LlE3HtD
uHfL]D^H/D$0QHD$(HQHH
D8HeWQHHE3HWHHt	B,<vLLAH̃IHWHHHQLAH\$Ht$WH AHWHHHEtEHt@HcH
E3<HCHȉ{Htt$H+׊HHuc	HaaHt$8HH\$0H _HH
Z1<ḦT$SH H!HAatAHT$8HH [H\$Ht$WH 3H@qHفaH1HtEE3VH
;HtH
0VHOHFHxHHHu
CAHt$8HH\$0H _@SH HH3DKcH8
t
HA8uHHH [@SH aHوQ;ugHHu
CH#HH [@SH HA	w"9tD;IcHLH:HH [H\$H|$UHH`Mȸ!E#HvHeHeMH8?P@u>H:HM)HPHHMrHHME(MU$uV3HMYfofsf~E<t=uSH8tGHHHMb))M'?uHx@u܁HeM(M}u3}t=uH`8ufMHUHMHMHuOH}HtHHHHHEHcHHHHHHtSDHMHNHHȊt%A HA:uDHD8tHuފHH\$pH|$xH`]H\$WH0HIHL$ HH<H\$@HH0_H\$WH0HIHL$ HHH\$@HH0_H\$WH0HIHL$ HHH\$@HH0_@SH HHIHH [@SH HHAHH [@SH HHIHH [@SH HHIHH [@SH HHAHH [@SH yH(H:uRH9u	HHH [H\$WH A@HD8AZtVH9uH!T$0HT$0AaA1E3H
AP6HtH
P@xHHHvHH\$8H _H\$Ht$WH yHHg3Ht`H91uLTB<v
CE3H
?AP6HtH
PHOHFHxHHHHt$8HH\$0H _H\$Ht$WH yHH\3HtU8tQH9u8EE3H
AP5Ht"HD8t
HA8uHHHHHYH\$0HHt$8H _@SH yH+H9t BvtaHHHH [H\$WH 9	HHt;H:t5E3H
AP4HHt	3Ht
HcHLHH\$0H _̀yt
B<~AH3HHA HAHALAH\$WH HyHt4HAHA%HGH_HHOHHOHGHGHuH\$0H _̋&ШHcH
d@HuHH\$WH HHHt?E3H
AP 3HtHH
NHHHPHxHHu
CAH\$0H _HHXUVWATAUAVAWHhH\$HLHd$@)pH\$H)xUI}tAEt	EeuH
u&HL$0IH
uAE
DAQE3DAAADEoA%`EwAAɁ#ωMt%;t.ׁ3AƁsZ
@
7HL$00 HMHHHME(EfD$@\$HDEoE3ɅA3HL$0#AE{HME(EHT$0HMfEbHUHL$@THiHM׀8tW8At:P{|$HpxDEof@؉\$HQHH3KH_
uH,HL$0zHUHME(EHGHMfEHUHL$@HGHL$@HL$0
ШШ HMHT$0HME'(EHM fES(EHT$@HMfE(u]oDmwIDeϺ!UD#!U!U!UHMHMHMHMHMDeυEte%=u.HL$0!(D$0HL$0fE!(D$0fEEt$%=uHL$0!(D$0fEHL$0~!(|$03ɺ(}E%=CLM!UL`D$ <`t'!UHL$0HeHUHe;(D$0fE9!UHUHMHMHL$0}t|$8~D$8ADDeϋ
Шt8t.HMHT$@HL$0D$0S(D$0fD$@'HL$0|$Htx~@؉\$HI}tQH|$@t>>u2 HMIHL$0D$0HT$0HL$@AED$@eE3L!mD9mt_3HM<HDHHMHHL$0D$0HT$0HL$@pt
(D$@(u>E3H
APi-LHtH @`E3IHM<0}+E%=u{HCHMUHUHL$0D$0(D$0HL$0,fD$0(D$0HUHL$0fD$0(D$0HL$0,fD$0(D$0fD$0,Et]%=uOH|CHMD$0HUHL$0@(D$0HL$0,fD$0iHT$0HL$@H=CHL$@cHCf|$0HL$0LHT$0HL$@HM	(HMHzHHL$0D$0(D$0HL$0)fD$0HT$0HL$@E3}oAE3D9ewAEAAEDžt!Et%=tHUHL$@FxHMШt8HHL$@!&8|$Htx~L$H@ȉL$H+HMШtLHHL$@&L|$Htx~L$H@ȉL$HHM?|$Htx~L$H@ȉL$HШtMt(D$@AEf(t$@]oDmwIHL$@@A|EA#=huHT$@HPEukA#=pt=`uX3HM0(D$@HL$0{fD$0(D$0HUHL$0fD$0(D$0H@H%A;uU(D$@HCHHM8HHk}HHv8@RHHcCE3ADAA`AEAAEEAAD#t%3ɋ%A=t	H@gEt%3ɋ%A=t	H@=EEEA%t/3ɋ%A=tH@HL$@EuA#=xE3AE3EAEAAE%tc3ɋׁAƁu3AƁt/H>HMCHT$@HL$0D$0(t$0HT$@HMj 0)t$@EAAEDž	ШEAAAEDžtV3ɋA#=EEt8H?HMHT$@HL$0D$0(t$0A)t$@EtA#=tZEAAE׋ɁtltA#=t*EAAEυtNA#=tt>A#=u2Hq>HMHT$@HL$0D$0|(t$0)t$@ШEAIJAEDžt!3ɋ"<@AEEt	H>fEAAEDžt)3ɋ"<3EEt	H=/EEEEtN@3EEt2H=HM/HT$@HL$0D$0(t$0)t$@3Ɂ3EEE%t:
u2Hu=HMHT$@HL$0D$0@(t$0)t$@s-HM=HMHT$@HL$0D$0(t$06L$HI[@A(sA({IA_A^A]A\_^]̋Ѓ̋Ѓ̋Ѓ̋־Ѓ̋ƾЃ̋Ѓ̋Ѓ̋	Ѓ̋%Ëz%H\$Ht$WH H9AHHtaH!AjHtat]E3H
FtAP$Ht0DHH9"#HtH3>HH3HHu
CAH\$0Ht$8H _̋½Ѓ̋Ѓ̋
3``̋Ѓ̋~% ËrЃH\$Ht$WHPH!HAayH8@8Zt3,HH8DA0A	w(H
HT$@HHHHnHd$ HT$ d$(HL$0H_+HH+H~H
`9	t
HT$0yHT$0H@HUH;ucH#CH:{
HHt$hHH\$`HP_@SH0HHـ8X8ZHL$ |$(ufHһ8tZ8@t`8ZtHR(D$ H=:HfD$ HHL$ ШH:HE(D$ MHH^HH9HKaШH7HEHH7H oHH0[H\$Ht$H|$UAVAWHHpHE3HLD88e!AHu<[HMTWHMEx(EHM]fEHUeFL}ttH0HMbυt`HZD88tT3HMn[HMHHHME(EHMв]fE8HUHM}~L9>teFt
E<(HMrHHME(EHMв)fE(EfEHUHM(EfEHUHMZ(mEAHML9:t?(HHME7(EH`9HMfEz(EfE[EкHM(EHM]fE"HUIL\$pII[ Is(I{0IA_A^]@SH@HH&+ШuHHL$ H
9tUHH
0t02t5uHPHUHL$02HHL$ B"H4HL$ HL$ HG6HL$ iD$ HH@[H\$UVWHHPHHH
E8HeHeH
ϷE0NweCmEvHGv:Iv,KvMPHk6HM2HN6HA6H06H6΃O7SX_HH
*ÃNNGwyFsktJ$t!H5HMHMH*6HHMHHɺH
HMH5먃HIv#KvMH5Ht5wH`5kH<5_ORtxStgUtVWtEw1HH
 HMfH~)EH
HR5H65H5H4H4HeeE9L
i	]LEHUHM']uH+HME[H1؃IHH
@HM7fH~)EHu.HJ3HMH3HMA@]0M8Ct"At_uDEw<u7H3H,4HMHUHME(EfEH>t, HM HHME\HUHMO(E`H>uAt'H3HMt'H3HMrtHt2HML
*HLEHU\& HMHHHH\$pHP_^]@SH 3HHH [H\$WH0HH8HAHHL$ 
ШtbtTtFt8t*ttu[H%=H%4H%+H%"H%H%Hn%H]%uHHL$ D$ 
_HH\$@H0_HHXHpHx L@UATAUAVAWHhH3)p)xLHy!UMHHu@u@808$Deu,ELEHUoHMH9ut
E}HLHuHu@u@uD@+A:AM!U+!U(}ϋǃ+tuШGH9utGH=T$uH(EHM߲ fE(EHMHfE(EfEH
$EEEEШMtCH=#uH f}HM(EHMHfE(})}LmaH#uHHM`Lm(}>ŰШt9H9utH=>#H/#uHHMAAH]HHS8$u*ELEHUoHMH9uFAAHD88AM+#H@80tHHuoHMH/(EHUHMfEH}(u)ut. fuHM(EHUHMfEt(u)uMt. f}HM(EHUHMfEA(u)uE3@Et
HD8.tnH+HMuHUHMEHHM(EfED8(t#
~HUHME(u)uFHD8(t[HM#fofsf~M׀tx~M@ȉM(uHvtHHf@tHM(uϋ`Шt8<ucEHMMHUHME(u)u2<u+HM}tx~M@ȉM(u@t-H-HMHUHME(u)u@t-Ht-HMHUHMEV(u)uD8mtHI-fuHM(u)uD8mtH*-fuHMl(EfEϿEM9.tqA~uFM9/tA HMIHME(EHM fE(EIfE@AFtAEA HM8IM9/t, HM#IEHM_HUHMR	}D8mtm
(E$E9uI96tnA~uPI91tKHMIHME(EHM fE(EIH8HMsI91tHM[IĺI(|$pL$Is8HI[0I{HA(sIA_A^A]A\]LSHPHMK3L>IK!D$8ISIK!D$HL$ HHHP[H\$UHH`HHMH388?tI8XtHUHHHH9MuH0'H$nH)HMIeLMHHML$ LyHMHHUE끺HMHUHDHH\$pH`]H\$Ht$ UHHPTH
s*
HM3҉;-.
EH?:HH8uOH8u#HMHͩ
HH8u먀8$HMu	f/!E3H3E3HMв8H}ut	s	E e }M~	(EBHIHM;H}=EtE(EHUHMfE+H(EfEЀ8@tKHME	(EfEH$HM(EHUHMfE(EfEЋu؋MU tH}t	uAtAuH}
H\8t8@tRHD
Zt'u#AuHeHUeHMHUH}uHHt$xHH\$`HP]H\$Ht$H|$UHH`L3DHA8QDVuMH5#LAuAH%A<	w*M/LmHcHt	HMHM3A@+tA<wLHAHcHMHL$AA:uAMLA:uEt%HtHM#ZHM@Ht2HM~HHMHHHMEHE	HMLL\$`HI[IsI{ I]@SH HH
p9_u5y_u/HH
ZHAH
JvHH#CcHH [@SH H0HH [H\$Ht$H|$UHHPHDAAAt
r3HHee
HHTt{tmt_tturH4%`H%WHMAH&%HHMHHME(EfE"H$H$H$HMHeet	(EfEHMHUHM(EHHHäHE$H\$`HH|$pHt$hHP]@SH H>HH [H\$UHHPHpHHee8<0<1~-<3~ <4t5<5t,6<w{Ha"HP"H?"H."HMHHϩu+H#"HM6HUHME(E(EHHH\$`HP]H\$Ht$Lt$UHHPDUHH
wIHeAADUIEH
QD	EAAE+7E;"9AEtHAHH
AA;vKHeHUAE,AHMEDU`HMY(EHMHfE|(EHM>fEH}(EfE8$uIHe ^fEHMw(EHHfE8tIH4AHMm(EAHH7EHeHUAD6AE>EDUHMqL5¡AEu2H8&uHLHH
H8*uHSHH
IH
H#CcHt$hHH\$`Lt$pHP]H\$Ht$H|$UHH`E3HHH
aAP4HHtH @`3HHHeLMHeLǶd$ HUHM!E!E(EHM fE(EHMHfE(EL\$`IsHI{ I[I]HHXHpHxUATAUAVAWHhHH3H
UL8u#SHMIH,6<v9_t
D1HA6H
A)u(8t D1HA=H
ޟAFvDADGD;tD}A$D#H]ED}EA$9@HhHMHUHMEJH_HM(EfE8tAM HMHHHME(EHUHMfE3HUHME(EH
fE
HH
О<@ԞL!UH΃`H
H]HMt$ <`!ULMHUH](EfEA|@HMv HMHHHME(EHUHMfE(E3fEz!ULMHUH]=}w@8umEADD}VHMWHUsHM}t@8p~M@ȉMߋ@t)HMHUHMEB(EfE'HM}t@8p~M@ȉMI9$t=(HMHUHME(EHM)fE(EfEE3H
APLHtX`HLIHM'HM(HMH-HHMEi(EHM)fEHUHMH
z`<`tEtHUHM'
Y@HMtHHM#}t@8p~M@ȉMߋHM@t#HHM##}t@8p~M@ȉMMt(EAM'
H&L$HI[0Is8I{@IA_A^A]A\]@SH 3HxHH [H\$WH H9Hu2HHXHHH\$0H _̃y$ ÊAH\$WH HQ3HtH:HtHHXH踥HH\$0H _H\$Ht$WH HyHHHXH胥HӄuH~HHXHgHH\$0Ht$8H _̋Q3t
BHcHAH\$WHPH3HL$0_`HL$@HHHL$ D$ D$ 'H'H\$`HHP_H\$Ht$WH HzHHEtHH认HzHHDHA H;sRH;v3WH
ęAHtH HtHKHtHHCH+HCHs H+HA HC HHCH\$0Ht$8H _H
1u3ÍB<	wƒ/HH
E3A@%tٍB<w4AADHH
A:u֊HH
ҘA:uAÃHHXHpHx L@UHH`HHHe!M3HeH!MH{A/1~d9C2HcHtHMHӠH}BHHMdHUHME(E!MHuЄHMu HM>HMHE HtHa;uE|HuHHHE3HM3%H0fH~)EHEHt.{1u(~HM衼HUHME(E)EHtHUHM(EL\$`HI[IsI{(I]H˺HHB΃BZ_pHHsOD9t^tI/6~/8CHcHbHHӠn?CH+HJCHMЃHHcHӠ*mp?t0@~EBCu7DHHMm;HHy0t
E3H뽃TGSP+;uCHMHfHcHӠƿHu(EH$qhHcHMH(yH
ʔHH
01t0΃w(EHUHwH+H
(EHUHMfEMHM(,HMEqHUHM$HM,HMEHHUHMHM,HMEHUHM3HM)HMEHUHM(E'H3HMm(EHM fE(EHUHMfE[(ECHMHHcHӠE3HM3zfH~EHEuVMWY/_vHHA`DF~uJK@CHMHHcHӠ@t'HƊHMHHxuـ@u
HHcECHMЃHHcHӠ茸H1HM8?u)HHMH8@uHHHHMHHM}CCCoCHM9HHcHӠ6[H}m	@SH L
HHH [@SH L
HHH [H\$H|$UHHPLHHe!UHA$tt=tHHH"HMqH?t HMܿLL
>IHULHELEfsf~EA@<$t^H˺lILGA5AtntZtHuIL	ILH?tH5HM H0HIL@H
HMHMHXHME裵(EHMHfE2(EHH\$PH@]H\$WH@HH
$uH譫E3u HL$ >HL$ EtHx8t
HHxD$ HHxL%xL-x
$HH$HĀA_A^A]A\_^]LSHPIcMKIcL%D$ !D$8IS!D$HHvHHP[H\$H|$UHHPHxH8tW8Zu HeHeEHwjHMŻHrHHMHHME莦&HIHMHMENEв)H蔦H\$`HH|$hHP]H(LQwA@A3A8_u
MAL0wA,A<A8$ME2LwAB$I@8PLDMLvE8t|A,Ft&A8Jt/A8K|A8M~A8O~A8QfMLvKMLvA,0<	w!A/HLLjv	]I/5~gAM+CA+A+
MELuAA<wREA0AAɁʋ
A"DAtAtAt6S+@&ٺr|MLQuKAA<ML1u0t{A+tlA+t`A+tSA+tDA+t4A+t$A+tA;xph` A39uMúLtٺ~EAAMËLgt
AA"DA}SºAttt3@At"AtAtAu

	H(@SH HsHـ8t$8AtHHHs
QHH [@SH HfHH [@SH0HH踣HL$ rHHG}H}HRs8@u
HHCsHH0[H\$H|$UHH`HyHs8THeLMHeLLjd$ HUHM!E!E(EHM fE(EHMHfE苡(EHr8@HH趢HortxHM[`HMHݗHHME(EHM'fEEHUHHr8@u
HHq:8@tHj#8u
H蜢}HHq8@uH\$Ht$ UWATAVAWH$HHH)H3HE3IIHLMue|
MtHtH`HL$X3HL$0DB RMHt$0H|$8Ld$@Au
Dd$HHuD$HHD$0LHD$PHT$PHhHMHD$(MHD$`HD$ HTHM3HcHtKAt"HuHD$@H;u)x*H;v%{MtqHtyfD&HD$@H;tqfD$FHwLD8d$ptHL$XHH399L$I[0IsHIA_A^A\_]HuHD$@H;ufDd~H\$UVWAVAWH$HH'H3Hp
IIHLMuzs
MtHtH
HL$Xp3HL$0DB QHd$@MHt$0H|$8Au
Dt$HHuD$HHD$0LHD$PHT$PH
HMHD$(MHD$`HD$ OHMC}HcHtIAt"HuHD$@H;u(x(H;v#uMtkHtyHD$@H;tlHuH|$ptHL$XHp
H37H$HĀA_A^_^]HuHD$@H;uD>H\$Ht$ UWATAVAWH$HH%H3Hp
E3IIHLMu	y~
MtHtH
HL$X3HL$0DB kOMHt$0H|$8Ld$@Au
Dd$HHuD$HHD$0LHD$PHT$PH
HMHD$(MHD$`HD$ lQHM_HcHtKAt"HuHD$@H;u)x*H;v%{MtqHtyfD&HD$@H;tqfD$FHDtLD8d$ptHL$XHp
H35L$I[0IsHIA_A^A\_]HuHD$@H;ufDd~H\$UVWAVAWH$HH>$H3HIIHLMu^w}
MtHtH`HL$X3HL$0DB MHd$@MHt$0H|$8Au
Dt$HHuD$HHD$0LHD$PHT$PHhHMHD$(MHD$`HD$ (MHMw|HcHtIAt"HuHD$@H;u(x(H;v#uMtkHtyHD$@H;tlHrH|$ptHL$XHH324H$@HA_A^_^]HuHD$@H;uD>H\$Ht$ UWATAVAWH$HH"H3HE3IIHLMuuf{
MtHtH`HL$Xc3HL$0DB LMHt$0H|$8Ld$@Au
Dd$HHuD$HHD$0LHD$PHT$PHhHMHD$(MHD$`HD$ NHM跉HcHtKAt"HuHD$@H;u)x*H;v%{MtqHtyfD&HD$@H;tqfD$FHpLD8d$ptHL$XHH32L$I[0IsHIA_A^A\_]HuHD$@H;ufDd~@SH0HMttH@IʐH
H0[@SH0|LuHA HI DALHc
cv#ns2txuWDAuxP1VH@IʐH@H0[@SH0|LuHA HI AHc
cvPU2}xuYDAcEHH	NdEHH	cEHH	.dH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXLHAHDHDHu
HHLALMBHAB8Et63AB8A0D؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPH\$HAXALLHHHDHu
HHLALMBHAB8Mt73AB8IH0L؀9~Aɀa:IBHIJHE+BHIBHH\$EBPE~~HHXHhHpHx AVH IADH3HHt
HHxtHALtt;}ƃH\$0Hl$8Ht$@H|$HH A^EHHXHhHpHx AVH IDAH3HHt
HHxtHAf;tt;}H\$0Hl$8Ht$@H|$HH A^H\$E3HE~ELIBI9BuAztAA	AHH@HHHHA9tAE;|H\$E~hH\$H|$@HE3LIBI9BuAztA$A	AH@H@HHfHHA9tAE;|H\$H|$HD$(HAHD$0HA HHLALIHHHHHHHHHHHHHHHHD$(HAHD$0HA HHLALIHHHHD$(HAHD$0HA HHLALIHHHHD$(HAHD$0HA HHLALIHHHHD$(HAHD$0HA HHLALIHHHHHHHHHHD$(HAHD$0HA HHLALIHHH3HHAHAHAHA HA(HA0A8fA@APATHXH`H3HHAHAHAHA HA(HA0A8A@fABAPATHXH`H3HHAHAHA HAHA(HA0A8fA@APATHXH`HHhHD$(HAHD$0HA HLLI3HHAHAHA HAHA(HA0A8fA@APATHXH`HHhHD$(HAHD$0HA HLLI3HHAHAHA HAHA(HA0A8A@fABAPATHXH`HHhHD$(HAHD$0HA HLLI3HHAHAHA HAHA(HA0A8A@fABAPATHXH`HHhHD$(HAHD$0HA HLLI@SH H3HHKHKHK HKHK(HK0K8fK@KPKTHXH`HHhHD$PHCHD$XHC LLKp+HCHH [@SH H3HHKHKHK HKHK(HK0K8fK@KPKTHXH`HHhHD$PHCHD$XHC 

LLKpHxL@+HCHH [@SH H3HHKHKHK HKHK(HK0K8fK@KPKTHXH`HHhHD$PHCHD$XHC LLKp*HCHH [@SH H3HHKHKHK HKHK(HK0K8fK@KPKTHXH`HHhHD$PHCHD$XHC LLKpE*HCHH [@SH H3HHKHKHK HKHK(HK0K8fK@KPKTHXH`HHhHD$PHCHD$XHC 

LLKpHxL)HCHH [@SH H3HHKHKHK HKHK(HK0K8fK@KPKTHXH`HHhHD$PHCHD$XHC LLKp-)HCHH [@SH H3HHKHKHK HKHK(HK0K8K@fKBKPKTHXH`HHhHD$PHCHD$XHC LLKp(HCHH [@SH H3HHKHKHK HKHK(HK0K8K@fKBKPKTHXH`HHhHD$PHCHD$XHC 

LLKpHxL(HCHH [@SH H3HHKHKHK HKHK(HK0K8K@fKBKPKTHXH`HHhHD$PHCHD$XHC LLKp'HCHH [@SH H3HHKHKHK HKHK(HK0K8K@fKBKPKTHXH`HHhHD$PHCHD$XHC LLKp'HCHH [@SH H3HHKHKHK HKHK(HK0K8K@fKBKPKTHXH`HHhHD$PHCHD$XHC 

LLKpHxLu&HCHH [@SH H3HHKHKHK HKHK(HK0K8K@fKBKPKTHXH`HHhHD$PHCHD$XHC LLKp%HCHH [HHHHHHHH@SH HHH落CHH [HAH"HHH@SH HH`!H`H [@SH HH`!H`H [@SH HH`c!H`H [@SH HH`?!H`H [@SH HH`!H`H [@SH HH` H`H [@SH HH` H`H [@SH HH` H`H [@SH HH` H`H [@SH HH`g H`H [@SH HH`C H`H [@SH HH` H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`kH`H [@SH HH`GH`H [@SH HH`#H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`oH`H [@SH HH`KH`H [@SH HH`'H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`H`H [@SH HH`H`H [HIH:u	At@SH HHSHH [H\$WH HHH	,H'HHHH#H\$0H _H\$Ht$WHH{H3H$HHH8H{HSHL$8@HoHHD$@HK LKLHT$0H	M	LD$0LCHL$(HL$`HD$ MHL$`KH$pH$|$PtHL$8H@蹸H$H3L$I[Is I_H	8H	$H	H	 H	H\$Ht$WH`HcH3H$PHHH8HcHSHL$8@HWHHD$@HK LKLHT$0H	M	LD$0LCHL$(HL$`HD$ MiHL$`H$XH$|$PtHL$8H@衷H$PH3L$`I[Is I_H	 H\$Ht$WH`HkH3H$PHHH8HkHSHL$8@H_HHD$@HK LKLHT$0H	M	LD$0LCHL$(HL$`HD$ MHL$`w(H$`H$|$PtHL$8H@詶H$PH3L$`I[Is I_H	H\$Ht$WHHsH3H$HHH8HsHSHL$8@HgHHD$@HK LKLHT$0H	M	LD$0LCHL$(HL$`HD$ MHL$`H$hH$|$PtHL$8H@豵H$H3L$I[Is I_H	$~H\$Ht$WHH{H3H$HHH8H{HSHL$8@HoHHD$@HK LKLHT$0H	M	LD$0LCHL$(HL$`HD$ M-HL$`$H$pH$|$PtHL$8H@蹴H$H3L$I[Is I_H	,}H	0}H	(}H\$Ht$WHHsH3H$HHH8HsHSHL$8@HgHHD$@HK LKLHT$0H	M	LD$0LCHL$(HL$`HD$ MAHL$`3(H$hH$|$PtHL$8H@豳H$H3L$I[Is I_H	0|''''''''''''xHxu2Ãu	|t3҉

HHH|HP4xHxu2Ãu	|t3҉

HHH|HP4xHxu2Ãu	|t3҉

HHH|HP4xHxu2Ãu	|t3҉

HHH|HP4ppppppppHHHDA:t	HuHt2	,Et	HuHHɀ90tD8uHɊHHˆuÍBL
[[uEtD6H\$H@Hl$PH A^_^HHXHhVWAVH HqHHHPD6&DE	HIH`H+-HG8"tHD$@H;GrHG@2>uEtD6H\$H@Hl$PH A^_^HHXHhVWAVH HqHHHPD6&DE	HIH`H+_-HG8"tHD$@H;GrHG@2>uEtD6H\$H@Hl$PH A^_^HHXHhVWAVH HqHHHPD6&DE	HIH`H+,HG8"tHD$@H;GrHG@2>uEtD6H\$H@Hl$PH A^_^HHXHhVWAVH HqHHHPD6&DE	HIH`H+W,HG8"tHD$@H;GrHG@2>uEtD6H\$H@Hl$PH A^_^HHXHhVWAVH HqHHHPD6&DE	HIH`H++HG8"tHD$@H;GrHG@2>uEtD6H\$H@Hl$PH A^_^HHXHhHp WH HqHHA
HP.&HIH`Hq,HG8"tHD$0H;GrHG2>ut.H\$8Hl$@Ht$HH _HHXHhHp WH HqHHA
HP.&HIH`H+HG8"tHD$0H;GrHG2>ut.H\$8Hl$@Ht$HH _HHXHhHp WH HqHHA
HP.&HIH`Hq+HG8"tHD$0H;GrHG2>ut.H\$8Hl$@Ht$HH _HHXHhHp WH HqHHA
HP.&HIH`H*HG8"tHD$0H;GrHG2>ut.H\$8Hl$@Ht$HH _HHXHhHp WH HqHHA
HP.&HIH`Hq*HG8"tHD$0H;GrHG2>ut.H\$8Hl$@Ht$HH _HHXHhHp WH HqHHA
HP.&HIH`H)HG8"tHD$0H;GrHG2>ut.H\$8Hl$@Ht$HH _H\$Hl$WH HHhHuN	GuH{tppH-3IcPc,RHC{(YCAS,, D.{A*HtIxu	|ujAy	K0ARCA< t(<#t<+t<-t
<0u?K09K03K0-K0 'K0!A.@k@k0>k<@kTHt6HCKAhHCH0t&C(H\$@Hl$HHt$PH A_A^_H\$Hl$WH HHhHu	uH{tppH-DcPc,NHC{(UCAS,, K08K02K0,K0 &K0 Hs0@s@{8s<@sTHt[HCKAHC9s,t{,u+ppwC(H\$0Hl$8Ht$@H _H\$Hl$Ht$WAVAWH 3HH9hub8H9itL=f@xxu
|HLs4Hs8|

A..HCkPk,CAHC9k(CAS,, D.{A*HtISxu	|ujAy	K0ARCA< t(<#t<+t<-t
<0u?K09K03K0-K0 'K0!A.@k@k0>k<@kTHt6HCKAhHCHtp)C(H\$@Hl$HHt$PH A_A^_H\$Hl$WH HhHu#HytppH-l=cPc,NHC{(UCAS,, E.f{B*HtI<xu	|upAy	K0AXCBA;t,#t!+t-t0u?K09K03K0-D	c0'K0!A.@k@k0>k<@kTHt:HCfKBfXHCH]t;C(H\$@Hl$HHt$PH|$XH A^A]A\HHXHpHxLp AWH 3HH9huH9qtppL=&6Dw!sPs,HC9s(CBS,fA+fZwCBBL8΍B8C,tkt^t(tHFHH+
f{B*tHS8H4HC HC HHωK8s8f{B*tHS4HC HC HK4K0ىK4CBA;t0#t%+t-t0K0|K0vK0pD	s0jK0dHs0@s@{8s<@sTPDCBCTHhHt
HhH9ptHhAf;u{(C(tZHCfKBfFHCpp#C(H\$0Ht$8H|$@Lt$HH A_[HHXHhHpHx AVH 3HH9hudH9qtppL54o!sPs,HC9s(CBS,f+fZwCBBL0΍B1K,tkt^t(tHFHt*f{B*tHS8H<HC HC HHωK8s8f{B*tHS4HC HC HK4K0ىK4CB;t2#t(+t-t0K0K0zK0t	k0oK0iHs0@s@{8s<@sTUSBCTHhHAH9Au@8qtC(+{(&C(HhH@HhHfHhHteHCfKBf?HC9s,t{,u1ppC(H\$0Hl$8Ht$@H|$HH A^HHXHhHpHx ATAUAVH 3HH9huPH9itL-1Dg!xx$u
|HLs4Hs8|

A..HCkPk,fCBfHC9k(CBS,fA+fZwCBBL(͍B)K,H.~C,b$t{tot(t;HFH.)f{B*Ht
H色xu
|9.}I>E.f{B*HtI蠭xu	|upAy	K0AXCBA;t,#t!+t-t0u?K09K03K0-D	c0'K0!A.@k@k0>k<@kTHJt:HCfKBfXHCH5t@C(H\$@Hl$HHt$PH|$XH A^A]A\HHXHhHpHx AVH 3HH9hu(H9qtppL5r.o!sPs,HC9s(CBS,f+fZwCBBL0΍B0C,tkt^t(tHgGH(f{B*tHS8HHC HC HHωK8s8f{B*tHS4HC HC HK4K0ىK4CB;t2#t(+t-t0K0K0zK0t	k0oK0iHs0@s@{8s<@sTUSBCTHhHAH9Au@8qtC(+{(&C(HhH@HhHfHhHtZHCfKBfAHCppC(H\$0Hl$8Ht$@H|$HH A^	Q0	Q0	Q0	Q0	Q0	Q0	Q0	Q0	Q0	Q0	Q0	Q0ø9xu
9|t3ø9xu
9|t3ø9xu
9|t3ø9xu
9|t3ð̰̰̰̋xu|uÃu	|t2Ëxu|uÃu	|t2Ëxu|uÃu	|t2Ëxu|uÃu	|t22222̃|u
9xt3̃|u
9xt3̃|u
9xt3̃|u
9xt32222̃a8̃a8̃a8̃a8̃a8̃a8̃a8̃a8̃a8̃a8̃a8̃a8̊AA< t(<#t<+t<-t
<0uI0I0I0
I0 I0̊AA< t(<#t<+t<-t
<0uI0I0I0
I0 I0̊AA< t(<#t<+t<-t
<0uI0I0I0
I0 I0̊AA< t(<#t<+t<-t
<0uI0I0I0
I0 I0̊AA< t(<#t<+t<-t
<0uI0I0I0
I0 I0̊AA< t(<#t<+t<-t
<0uI0I0I0
I0 I0AB t,#t!+t-t0uI0I0I0
I0 I0AB t,#t!+t-t0uI0I0I0
I0 I0AB t,#t!+t-t0uI0I0I0
I0 I0AB t,#t!+t-t0uI0I0I0
I0 I0AB t,#t!+t-t0uI0I0I0
I0 I0AB t,#t!+t-t0uI0I0I0
I0 I0@SH 3Hp	tCHhSAHtHhHxtHhyu	C(C(M2H [@SH Hًxu	|tu
|ua3Hk	tAHhSAHtHhHxtHhyu	C(C(2H [@SH 3H	tCHhSAHtHhHxtHhxu	C(C(E2H [@SH 3H	tHHhDCAHAH9AuytC($K(C(HAHhHDHhH2H [@SH Hًxu	|tu
|ud3H	tDHhSAHAH9AuytC(σK(C(HAHhHHhH~72H [@SH 3H	tHHhDCAHAH9AuytC($K(C(HAHhHDHhH2H [@SH ATHIBHhPtHhHxtHhtf;uK(C(H [@SH Hًxu	|tZu	|tLDCBCTHhHtHhHxt HhA tf;uK(C(H [@SH ATHIBHhPtHhHxtHhsf;uK(C(H [DIBLATHhHAH9AuytA@((AH(!A@(HAIhHfD
IhHHыxu	|tYu	|tKDBBBTHhHAH9AuytB(&J( B(HAHhHfDHhHDIBLATHhHAH9AuytA@((AH(!A@(HAIhHfD
IhH@SH 3H(tAHhSAHtHhHxtHhjtu	C(C(H [@SH 3H`tAHhSAHtHhHxtHhtu	C(C(H [@SH 3HtAHhSAHtHhHxtHhsu	C(C(H [@SH 3HtFHhDCAHAH9AuytC($K(C(HAHhHDHhHH [@SH 3HtFHhDCAHAH9AuytC($K(C(HAHhHDHhHH [@SH 3H@tFHhDCAHAH9AuytC($K(C(HAHhHDHhHH [@SH ATHIBHhPtHhHxtHhpf;uK(C(H [@SH ATHIBHhPtHhHxtHhof;uK(C(H [@SH ATHIBHhPtHhHxtHhoof;uK(C(H [DIBLATHhHAH9AuytA@((AH(!A@(HAIhHfD
IhHDIBLATHhHAH9AuytA@((AH(!A@(HAIhHfD
IhHDIBLATHhHAH9AuytA@((AH(!A@(HAIhHfD
IhH@SH HAHQAATHHfPtdHhHtHhHxtHh#pu	C(C(HCHKAHCu2H [@SH HAHQAATHHfPtdHhHtHhHxtHhou	C(C(HCHKAHCua2H [@SH HAHQAATHHfPtdHhHtHhHxtHhnu	C(C(HCHKAHCu2H [H(HAHDAAATHHfB@thHhHAH9AuytB($J(B(HAHhHDHhHHBHJAHBu52H(H(HAHDAAATHHfB@thHhHAH9AuytB($J(B(HAHhHDHhHHBHJAHBuV2H(H(HAHDAAATHHfB@thHhHAH9AuytB($J(B(HAHhHDHhHHBHJAHBu2H(ATATATATATAT̃I83HA0A@AHCHk(LhHD$ LHT$PIDK0AtAuLDƲ0I3Hȍ}|C0AtLDƲ IDžAH\$XHl$`Ht$hH0A_A^_H\$Hl$Ht$ WAVAWH0AAHAd]ACt3DGSt_XtoZtac3>g~itgnt[ot8ptstutRxuePMjUA8A<EǺ1I0AtK0H]I0
E3KX(u2[|u
D9xB{@8S03fD$P3D$RAt.AtD$P-AtD$P+AtD$P IKAAuAtEE2AEut*DxHCHk(LhHD$ LHT$0ID蛉K0AtAuLDAIw3H跄}|C0AtLDAIwAHL$8H3fL\$@I[8Ik@IsHIA_A^A]A\_H\$Hl$Ht$ WATAUAVAWH@HAUH3HD$8ABXHٍnD~d[;Ct2DGSt^;toZtac34g~itgnt[ot8ptstutRxuePM$`UA8A<EǺ1I0AtK0HTI0
E3G&u2l{@_S03D$03fD$4Do At2At
G-fD$0At+At	fDl$0IKBAf+fAuAtEE2A0f+fAEut/fDd|0If;t	f;t2A$afD|0Is4+sP+uLK(DHhA^vHCHk(LhHD$ LHT$0ID藈K0AtAuLDAIv3Hׂ}|C0AtLDAIuAHL$8H3cL\$@I[8Ik@IsHIA_A^A]A\_H\$Hl$Ht$ WATAUAVAWH@HuRH3HD$8ABXHٍnD~d[;Ct2DGSt^;toZtac32g~itgnt[ot8ptstutRxuePM ^UA8A<EǺ1I0AtK0HRI0
E3E%u2|u
D9xi{@_S03D$03fD$4Do At2At
G-fD$0At+At	fDl$0IKBAf+fAuAtEE2A0f+fAEut/fDd|0If;t	f;t2A$afD|0Is4+sP+uLK(DHhA|sHCHk(LhHD$ LHT$0ID赅K0AtAuLDAI/s3H}|C0AtLDAIsAHL$8H3aL\$@I[8Ik@IsHIA_A^A]A\_H\$Hl$Ht$ WATAUAVAWH@HOH3HD$8ABXHٍnD~d[;Ct2DGSt^;toZtac30g~itgnt[ot8ptstutRxuePM \UA8A<EǺ1I0AtK0HPI0
E3D%%u2l{@_S03D$03fD$4Do At2At
G-fD$0At+At	fDl$0IKBAf+fAuAtEE2A0f+fAEut/fDd|0If;t	f;t2A$afD|0Is4+sP+uLK(DHhApHCHk(LhHD$ LHT$0IDK0AtAuLDAIep3H}|C0AtLDAI9pAHL$8H3M^L\$@I[8Ik@IsHIA_A^A]A\_̀yA*t	HQ4MHA HA PQ4y	I0ډQ4@SH yA*HtHQ4H [铔]t$xu	|uC4y	K0؉C4H [ÀyA*t	HQ4ՔHA HA PQ4y	I0ډQ4̀yA*t	HQ4)HA HA PQ4y	I0ډQ4@SH yA*HtHQ4H [o^^t$xu	|uC4y	K0؉C4H [ÀyA*t	HQ4鱕HA HA PQ4y	I0ډQ4fyB*t	HQ4HA HA PQ4y	I0ډQ4@SH fyB*HtHQ4H [F^t$xu	|uC4y	K0؉C4H [fyB*t	HQ4逖HA HA PQ4y	I0ډQ4fyB*t	HQ4ЖHA HA PQ4y	I0ډQ4@SH fyB*HtHQ4H [%_t$xu	|uC4y	K0؉C4H [fyB*t	HQ4LHA HA PQ4y	I0ډQ4̸	̸	̸	̸	̸̸̸̸HHHHH}HuHmHeÃ2ttt!ttu)øøøÃttރt3A;,A-A/AO1A2A4Ac6A7A9Aw;A=A>H\$Ht$WH HA HHA HxHt3HwHt*DAt7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _H\$WH 3HT$8H\$8Hu2xu
|uZ_ȋO</tt7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _H\$Ht$WH HHY HA HpuSX^2O<,t>t7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _H\$WH 3HT$8H\$8Hu2xu
|u[W]ȋO</tt7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _H\$Ht$WH HHY HA Hp,uUP[2O<,t>t7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _H\$WH 3HT$8H\$8Hu2xu
|4uTXZȋO</tt7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _H\$Ht$WH HHY HA HppuRX2O<,t>t7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _H\$WH 3HT$8H\$8H&u2xu
|xuQWȋO</tt7ttt(t&3"tt
tHHt*HtHtH;uHcG(HG(G(fO(G@H\$0Ht$8H _̋Q0tQ0E3AP̋Q0tQ0E3APa̋Q0tQ0E3APE̋Q0tQ0E3AP̋Q0tQ0E3APE̋Q0tQ0E3AP)̋Q0tQ0E3AP̋Q0tQ0E3AP)̋Q0tQ0E3AP
̋Q0tQ0E3AP̋Q0tQ0E3AP
̋Q0tQ0E3AP̺A<AQ8i̺A<AQ8̺A<AQ8̺A<AQ8e̺A<AQ8̺A<AQ8̺A<AQ8a̺A<AQ8̺A<AQ8̺A<AQ8]̺A<AQ8̺A<AQ8H\$Ht$WH HA HHA q8DAHHHcCT茇H?u
HHHHcCPH\$0Ht$8H _H\$Ht$WH HA HHA q8DAD>D2HcH@HːK4H\$HH0_H\$WH0|HuHA HQ DBDA4HIHT$@3H|$@DG
SbxPHD$@HHHKx{f8$uud}p
;DC9>2HcH@HːK8H\$HH0_HA HA PQ8HA HA PQ8HA HA PQ8HA HA PQ8H(H	Hu88>2H(H((H(H9uU8>2H(H(H9u-8=2H(H(H9u8=2H(H8:D$`uDDJBH8ÉD$ #u7u=2H8:D$`uDDJBH8ÉD$ U%u|75=2H8:D$`uDfDJBH8ÉD$ 'u;7<2H8:D$`uDfDJBH8ÉD$ (u6<2@SH y,HHI<%|u]Hd$0,0<	wGA
HT$0~Y~3HD$08$u)xuH3A`	
ǃ|
ǃ||uXHKHT$8Hd$8A
YxHT$8H
HBHCux#:$ud}
;O
H [5;2@SH y,HHI<%|u]Hd$0,0<	wGA
HT$0zX~3HD$08$u)xuH3A`	ǃ|
ǃ||uXHKHT$8Hd$8A
XxHT$8H
HBHCux#:$ud}
;O
H [4:2@SH y,HHIf%|ubHd$0f0f	wHA
HT$0X~4HD$0f8$u)xuH3A`	ǃ|
ǃ||uYHKHT$8Hd$8A
*XxHT$8H
HBHCu x$f:$ud}
;O
H [392@SH y,HHIf%|ubHd$0f0f	wHA
HT$0W~4HD$0f8$u)xuH3A`		ǃ|
ǃ||uYHKHT$8Hd$8A
WxHT$8H
HBHCu x$f:$ud}
;O
H [282̰̰̰̰H(y,ty,t2X82H(H(y,ty,ts2,82H(H(y,ty,tG282H(H(y,ty,t272H(H(y,Hty,t172]|uRxuIHc
LLHJNHNM;t*AHB I@tt
tuHB IѰH(H(y,Hty,t`172]|uRxuIHc
LLHJNHNM;t*AHB I@tt
tuHB IѰH(H(y,Hty,t062]|uRxuIHc
LLHJNHNM;t*AHB I@tt
tuHB IѰH(H(y,Hty,tH062]|uRxuIHc
LLHJNHNM;t*AHB I@tt
tuHB IѰH(̰̰̰̰@SH0|xuwHc
cv/P52YDA/4ְH0[@SH0|xuwHc
cv.42YDAHL$@H3H\$hHt$pHP_H\$Ht$WHPHJH3HD$@yTHtnAP~gHqH3t~DHT$4d$0HL$0AHv~u1DD$0Et'HCLK(HhHD$ HT$4	;{Pu'K(!HCLI(DCPHhHSHHD$ j	HL$@H3H\$hHt$pHP_H\$Ht$WHPHrH3HD$@yTHtnAP~gHqH3t~DHT$4d$0HL$0AHv覭u1DD$0Et'HCLK(HhHD$ HT$4;{Pu'K(!HCLI(DCPHhHSHHD$ HL$@H3H\$hHt$pHP_H\$Ht$WHPHH3HD$@yTHtnAP~gHqH3t~DHT$4d$0HL$0AHvάu1DD$0Et'HCLK(HhHD$ HT$4;{Pu'K(!HCLI(DCPHhHSHHD$ HL$@H3+H\$hHt$pHP_H\$Hl$VWAVH0E3HD8qTAPHqHALKHL$PfDt$PHILc@fHc~WHhDD$PHt
HhL9pt HhArf;uK(C(HH;{Pu'K(!HCLI(DCPHhHSHHD$ H\$XHl$`H0A^_^H\$Hl$VWAVH0E3HD8qTAPHqHALKHL$PfDt$PHILc@zHc~WHhDD$PHt
HhL9pt HhA膸f;uK(C(HH;{Pu'K(!HCLI(DCPHhHSHHD$ H\$XHl$`H0A^_^H\$Hl$VWAVH0E3HD8qTAPHqHALKHL$PfDt$PHILc@莦Hc~WHhDD$PHt
HhL9pt HhA蚷f;uK(C(HH;{Pu'K(!HCLI(DCPHhHSHHD$ H\$XHl$`H0A^_^H\$Hl$Ht$ WH03H@8iTAPHqHLKHL$@fl$@HILc@裥HcЅ~WHhDD$@HAH9Au@8itC(&K( C(HAHhHfDHhHHH;{Pu'K(!HCLI(DCPHhHSHHD$ H\$HHl$PHt$XH0_H\$Hl$Ht$ WH03H@8iTAPHqHLKHL$@fl$@HILc@賤HcЅ~WHhDD$@HAH9Au@8itC(&K( C(HAHhHfDHhHHH;{Pu'K(!HCLI(DCPHhHSHHD$ H\$HHl$PHt$XH0_H\$Hl$Ht$ WH03H@8iTAPHqHLKHL$@fl$@HILc@ãHcЅ~WHhDD$@HAH9Au@8itC(&K( C(HAHhHfDHhHHH;{Pu'K(!HCLI(DCPHhHSHHD$ H\$HHl$PHt$XH0_H\$Hl$Ht$WAVAWH HILHDPAAtHHxuEH|$`IcHD?'H;tuHAHt
HHxtHu		u5?*u8HHt
HHxtH?еu	IL;u?uEtD?H\$@Hl$HHt$PH A_A^_H\$Hl$Ht$ WAVAWH HILHDPAAtHHxuEH|$`Ic/'L&H	HAH9AuytA)MA	GH+ALH	H;LBK6L9I$HI$LpI$xt/
L;tD7>uEtD>H\$PHl$XHt$`H A_A^A]A\_HDHBA%@UHH`HE0HELMLE(HUHM Huz"JMtHEHUHELMHEHUHELEHE HEHUHE(HEHM0HEHEӖH`]@UHH`HE0HELMLE(HUHM Hu5!JMtHEHUHELMHEHUHELEHE HEHUHE(HEHM0HEHEGH`]@UHH`HE0HELMLE(HUHM Hub!JMtHEHUHELMHEHUHELEHE HEHUHE(HEHM0HEHE;H`]@UHH`HE0HELMLE(HUHM Hu JMtHEHUHELMHEHUHELEHE HEHUHE(HEHM0HEHEH`]@UHH`HE0HELMLE(HUHM HuJ JMtHEHUHELMHEHUHELEHE HEHUHE(HEHM0HEHEH`]@UHH`HE0HELMLE(HUHM HuJMtHEHUHELMHEHUHELEHE HEHUHE(HEHM0HEHEWH`]H\$Hl$Ht$WATAWH0H|$pIIHLMuHuM3HMHM;vQ:LL$pLEHI̋0H$HD$(HD$xHD$ 赚uo8"0LL$pLHID8H$HD$(HD$xHD$ dD7uH;u8"u@D86yu*"Ar+HHl$XH\$PHt$`H0A_A\_HHXHhHpHx ATAUAWH0E3IIHLL9l$pMuHuMAHMHM;vQLL$pLEHI̋0H$HD$(HD$xHD$ up8"0LL$pLHID8H$HD$(HD$xHD$ 訚fDlwuH;uC8"uA9D87yfD/u*""HHl$XH\$PHt$`H|$hH0A_A]A\H\$Ht$ UWATAVAWH$HHtH3HE3IIHLMuJMtHtH`HL$0G3HL$PDB MHt$PH|$XLd$`Au
Dd$hHuD$hHD$PLHD$pHT$pHhHMHD$(MHD$8HD$ \HMHcHu/HLD8d$HHD$0AtMHu3t/HLD8d$HHD$0HD$`H;upxpH;vkMtHt_yD&VHD$`H;uHDd7EHtHD$`H;u2HDd7]LD8d$HtHD$0*D$0H,LD8d$HtHL$0HH3L$I[0IsHIA_A^A\_]H\$Ht$ UWATAVAWH$HH@H3Hp
E3IIHLMu]MtHtH
HL$03HL$PDB MHt$PH|$XLd$`Au
Dd$hHuD$hHD$PLHD$pHT$pH
HMHD$(MHD$8HD$ HMHcHu/HLD8d$HHD$0AtMHu3t/HLD8d$HHD$0HD$`H;upxpH;vkMtHt_yD&VHD$`H;uHDd7EHtHD$`H;u2HDd7)LD8d$HtHD$0*D$0HLD8d$HtHL$0Hp
H3L$I[0IsHIA_A^A\_]@SH0HMtHHHHBtGEEDHHt8tA3AADOЀ	w!@σ;@9EDDHAH̍G<w	@σG<w	@σAA;t-A;s(EA;ru;vAAH@8HHHH@t@88t?Au}L+HEAtj"AuA\At'}tHEHKHtHHQ}tHEHKHtHH*Atހ}tHMHCHtHHL\$@I[0Is@I{HIA_A^A]A\]H\$Hl$Ht$ WATAUAVAWHPE3AEHL9*u&HOHtHH3cEt	A@"wHHL$(gL'ELd$ A$ID$
HHHu@A@f-uf+u
HHH	DŽ$jA`A0Af
DFAfA;f:sA+fA;f;f;$s
+f;f;s
+pfA;kp	f;sA+Qf;M	f;s
+4f;0p
f;s
-f

f;A
f;cHvf;A
f;Kff;A
f;1Hvf;A
f;Hvf;A
f;Pf;A
f;Hvf;r{A
f;HFf;rgA
f;@f;rQA
f;f;r;A
f;H&f;r'A
f;s~f;sA+u)CfvCfvACfw ɾtEuyD~sHAHHHBfAt:EDDHHftDf9t?AA0AEDDHAH3AAA`ADfA;f:sA+fA;yfA;jf;sA+ofA;jf;sA+Pf	f;GH
f;s
+0	f;'H
f;rAvf;H
f;r̍Avf;H
f;rAvf;H
f;rff;H
f;rAvf;H
f;vAvf;H
f;^Pf;H
f;DAvf;r{H
f;0AFf;rgH
f;@f;rQH
f;f;r;H
f;A&f;r'H
f;sf;sA+u)CfvCfvACfw A;t0A;s+E;ru;vEDHHHHE3HLd$ ftf9tt-@uL'D8l$@CHD$(2A֋Kto2"@uAa@t)D8l$@tHD$(HOHtHHWD8l$@tHD$(HOHtHH.@tAD8l$@tHL$(HWHtHH
AL\$PI[0Ik@IsHIA_A^A]A\_H\$Ht$H|$ UATAUAVAWHH@H:EEHu&IHKHtHH3Et	A@"wHHM`L+E3HULm8A}IEEnHz@~LEAՋ豢HU
HHHA#ŅtH@8H3E@@-u@+uH@8HHLm8AG<	w	@ǃ#G<w	@ǃG<w	@ǃAtEuDE{>HHHHBtOEEDHHt8tAIMcI3ILȍOЀ	w"DA>@9EDDHAHčG<w
DAG<w
DAAAt:E;s5AM;ruAH;v
IIELH@8HHpL#H@t@88tC@u}L+HEI֋Gtt"@uMg@t,}tHEHKHtHHHX}tHEHKHtHHH,@tIހ}tHMHCHtHHIL\$@I[0Is@I{HIA_A^A]A\]H\$Hl$Ht$ WATAUAVAWHE3AEHL9*u&HOHtHH3AEt	A@"wHHL$x]L'ML$A$ID$
HHHu@A@f-uf+u
HHHD$tjf
DŽ$
0D$Pf`D$(pAD$hfDVD$0p
D$XAD$8Af	D$pf
D$@p
D$`PD$HZD$lD$ D$$ D$,*D$4@D$D$lf;rvf;\$ *D$$f;rbf;\$,D$4f;rNf;\$<D$Df;r:f;\$LD$Tf;r&f;\$\sf;\$ds	DE+AAu-CfvCfvACDfwA AAt?E;s:M;ruAH;vIIEL0HHHHE3HL$ftf9tZ@u"L'D8$xHD$xgI֋t\"@uIq@t1D8$tHD$xHOHtHHHbD8$tHD$xHOHtHHH1@tID8$tHL$xHWHtHH
IL$I[0Ik@IsHIA_A^A]A\_H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ lHE3DHH\$@H0_H\$WH0AILHHL$ DHE3DH[H\$@H0_H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ |HE3DH{H\$@H0_H\$WH0AILHHL$ THE3DHsH\$@H0_HLAMtIHHLAMtIHHQHtHHHQHtHHHHHHHHH\$WH Ht&Hx~L‹ϺHHcH	xH\$0H _H(.H(øH̸H̍A<	w0ÍA<wWÍA<w7Ã̺0f;f:s
+f;k`f;sB
f;rҺf;]B
f;rf	f;GB
f;rPvf;3B
f;rPvf;B
f;zPvf;B
f;bPvf;B
f;Jff;B
f;0Pvf;B
f;Pvf;B
f;Pf;B
f;Pvf;rwB
f;PFf;rcB
f;@f;rMB
f;f;r7B
f;P&f;r#B
f;s}f;ou(Afv
AfvÍAfw HHHHH(H	Ht8t:H(H(HHftf9tVH(H(H9u52H(H(H9u
2H(̺0f;f:s+úf;[`f;[B
f;rֺf;EB
f;rf	f;/B
f;rPvf;B
f;rPvf;B
f;rPvf;B
f;jPvf;B
f;Rff;B
f;8Pvf;B
f; Pvf;B
f;Pf;r{B
f;Pvf;rgB
f;PFf;rSB
f;@f;r=B
f;f;r'B
f;P&f;rB
f;HH\$WH HcMtIHy#5x#H\$0H _H\$WH HcMtIx~	ԐHx#x#H\$0H _@SH0ALHHL$ 3HAD33H0[H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ HHADHGH\$@H0_@SH0ALHHL$ HE3D3H0[H\$WH0AILHHL$ HE3DHH\$@H0_H\$WH0AILHHL$ HE3DHH\$@H0_H\$WH0AILHHL$ dHE3DHcH\$@H0_H\$WH0AILHHL$ (HE3DH'H\$@H0_@SH0ALHHL$ HAD3'H0[H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ HADHH\$@H0_H\$WH0AILHHL$ XHADHoH\$@H0_H\$WH0AILHHL$ HADH;H\$@H0_@SH0ALHHL$ HE3D3H0[H\$WH0AILHHL$ HE3DHH\$@H0_H\$WH0AILHHL$ tHE3DHH\$@H0_H\$WH0AILHHL$ 8HE3DHWH\$@H0_H\$WH0AILHHL$ HE3DHH\$@H0_@SH0ALHHL$ HAD3H0[@SH0ALHHL$ HAD3H0[@SH0ALHHL$ SHAD3SH0[@SH0ALHHL$ #HE3D3;H0[@SH0ALHHL$ HE3D3H0[@SH0ALHHL$ HE3D3H0[@SH0ALHHL$ HAD3H0[@SH0ALHHL$ wHAD3H0[@SH0ALHHL$ GHAD3gH0[@SH0ALHHL$ HE3D3/H0[@SH0ALHHL$ HE3D3H0[@SH0ALHHL$ HE3D3H0[@SH 3HHL$0HD$0P_T$0EHtH [@SH03HHL$ HD$ PHT$ HHEHtHHH0[@SH HHuB3fu3HL$0HD$00LD$0H*!NbLHBzՔIIHHH?HHiʀD+AkdKH [@SH HHu3mu3HL$0HD$0LD$0H*!NbLHBzՔIIHHH?HHo@H;iʀHD+AkdKH [@SH 3HHL$0HD$0PT$0EHtH [@SH03HHL$ HD$ PHT$ HHEHtHHH0[WH\$Ht$WH HU3HHtHHdHEHH\$0Ht$8H _H\$Ht$WH H
3HHtHHHEHH\$0Ht$8H _@USWHH@HHHu=H@_[]úA$跮HtЃ?}΁?ne8HM8ee0}AHM蜈HM0軈=}wY+M0HU M H誏[9E8mH1]EHU )E Hw(C 7HHX	;9E8tHtMM0+C +}0AAk<+ȉyA<<ADAADADKAAkHcE8HUH)EHҌC ]HH賌Hc;9E0tHtE E8HC HcE H+IIHHHHH?Hk<+ȉy	AAHCHCH9{tH;CwH3HUStHFЈEP<0u@׈UPϊE`L}EAA	B<	wƒ0!B<wƒWB<wƒ7A;wKAM;tAEIHCHCMH9{tH;CwH3HRMȃtHF@NJЈEPL}HIHH:HCHCH9{tH;CwH3HmRtHF@HMXHEPL;uC<0u?AHCMHCH9{tH;CwH3H$RtHFЈEP<0u@׈UPB<	wƒ0!B<wƒWB<wƒ7A;wDAL;mtAEIHCHCH9{tH;CwH3HQtHF@NJЈEPEu!HMׄ]``HKHCH9{tH;CwB<vHtHJH=}HCHEHHCH9{tH;CwH3HQȃtHF@ψMP@ǀEtPt
et
puE`@8}`DHCHCH9{tH;CwH3HPtHF@<-EPA,+u2HCHCH9{tH;CwH3HuPtHF@NJȈEPD0ukrHCHCH9{tH;CwHHBH;BtHHBu@ψMHHKHCH9{tH;CwvHHAH;tHHAL;tfIC@88uLH;uL;tPE;~	mD;}\AɃADE;D;|D+EUEE]@Nj)"LEXHMHH$LEXHMHHH$H@A_A^A]A\_^]LD$HL$USVWATAUAVAWHHhL
3MHMtH9zu謘eHBAHEHHBH9ztH;BvIAI;AtHIAfA;uHEHUHEAHEfMAHErFEwELsHCH9{tH;Cv HHBH;BtHHBfA;uAfM'FuUMf-AABfAu=LsHCH9{t
H;Cv!HHAH;AtHHAfA;ufUBAfA_BfA@0@}PDf;LKIAHCH9{tH;CvLI@I;@tnHI@fA;tYAfAuJLsEHCDuPH9{tH;Cv HHAH;AtHHAfA;ufULMHUUAHKHCH9{tH;Cw"fA+fA;wHHAH;tHHAUMeA0LeЋωMMDfA;ucA@ADHCHCH9{tH;Cw9HHAH;At,DHHAfE;t0AfUfD;ufUAE`jAA`EAAA	E`/fA;\f:sA+Ff;)fA;8f;U`sA+"f;f;s
-f	f;p	f;s
-f		f;	f;s
-	f
f;p
f;s
-f

f;
f;s
-
nff;epf;s
-fIff;@pf;s
-f$f;f;s
-f
f;p
f;s
-f
Pf;Zf;s
-Pf;f;s
- f;*f;s
- n@f;riJf;s
-@Pf;rKf;s
-2f;r-f;s#-f;s+u)BfvBfvBfw A;wYEM;tAMLCAHCMH9{tH;Cv#HHAH;AtHHAfA;u׋MfUHuHLmXD}PLuHMeHH;LCHCH9{tH;Cv$HHBH;BtHHBf;ufMѸ0M;unf;uiuELCA+HCuH9{tH;Cw=HHAH;At0DHHAfD;t0AfUfD;uD@׸0fU`AAAf;f:sƒ0fA;pf;jf;s
+hf;_A
f;s
+Hf	f;?A
f;rHvf;+A
f;r̍Hvf;A
f;rHvf;A
f;rHvf;A
f;rff;A
f;vHvf;A
f;^Hvf;A
f;FPf;A
f;,Hvf;r{A
f;HFf;rgA
f;@f;rQA
f;f;r;A
f;H&f;r'A
f;sf;sA+u)BfvBfvBfw A;wUEM;tAMLcHCH9{tH;Cv HHAH;AtHHAfA;ufU0LmXD}PLuMeuEu!HMcAbHKHCH9{tH;Cw*AfA+f;wHHAH;tHHAAHCHEHHCH9{tH;Cv$HHBH;BtHHBf;u@fMEtPt
et
puAE‰}DAPLCHCH9{tH;Cv$HHAH;AtHHAf;uf-fUʸAf+DMfuALCHCH9{tH;Cv$HHBH;BtHHBf;ufM0@}`f;ueE`HCHCH9{tH;Cw:HHAH;At-HHAf;t0fUf;ufM0f;f:s
+f;k`f;sP
f;rҸf;]P
f;rf	f;GP
f;rBvf;3P
f;rBvf;P
f;zBvf;P
f;bBvf;P
f;Jff;P
f;0Bvf;P
f;Bvf;P
f;Pf;P
f;Bvf;rwP
f;BFf;rcP
f;@f;rMP
f;f;r7P
f;B&f;r#P
f;s}f;ou)AfvAfvAfw Ƀ
sdCE`DBDUE;EHCHCH9{t
H;CHHBH;BtHHBf;AQDUĺ0AAA`Af	A	Af
A
Aff;@f:s
++fA;fA;jf;sA+f;f;s
+fA;p	f;sA+fA;	f;sA+fA;p
f;sA+fA;
f;sA+ifA;dpf;sA+Jff;Apf;s
-f%f;f;s
-f
f;p
f;s
-f
Pf;Zf;s
-Pf;f;s
- f;*f;s
- o@f;rjJf;s
-@Qf;rLf;s
-3f;r.f;s$-f;sA+u)AfvAfvAfw Ƀ
sGHCHCH9{tH;Cv%HHBH;BtHHBfA;uϺ0fMBLmXAPDMDUDE`LuMeD}PuEtAEuZHMm\tALCHCH9{tH;Cv$HHBH;BtHHBf;ufMAHKHCH9{tH;Cw"fA+ȸf;wHHAH;tHHAM;tfIF@88uLI;uM;tPE;~	mD;}\AɃADE;D;|E+EUEEu@Nj)"LEHMHFLEHMHHhA_A^A]A\_^[]LI[IsMCWATAVH@ICISICL%}HIKL3AB:'$tB:'$HCH{HCtH;CwH3H!ȃtHF2HAHuHKH{HCtH;CwA<vHɃtHJHMHCHD$pHH{HCtH;Cw*H;H!tHGHL$ Y2A3AB:'$tB:'$HCH{HCtH;CwH3H!ȃtHF2HAHuHKH{HCtH;CwA<vHɃtHJHLH\$`Ht$hH@A^A\_HL$ XLMCSH@ICISICHIKLE3EAA:$%tA:(%AHBHBL9ZtH;BwL
IAI;AtHIAuAIA
IuHJHBL9ZtH;BwvH
HAH;tHHAHBHD$`HHBL9ZtH;BwLI@I;@tHI@uAA
MAA:,%tA:4%HBHBL9ZtH;BwL
IAI;AtHIAuAIA
IuHJHBL9ZtH;BwvLIHI;tHIHH@[HL$ JXHL$ 9XLI[IkIs MCWATAUAVAWH@3ISICIKHICLL%D}AfB;'$tfB;'$L{HCH9ktH;Cv H3Hȸf;tL~HfAHuHKAHCH9ktH;CwfA+fA;wHHJHhHHCH$HHCH9ktH;Cv1HL$ &SH;Hf;tLfAHAfB;'$tfB;'%L{HCH9ktH;Cv H3Hȸf;tL~HfAH
uHKHCH9ktH;CwfA+fA;wHHJHwGL\$@I[0Ik8IsHIA_A^A]A\_HL$ 6RLI[IkIs MCWH@ICISICH=IKLE3۽EA[AfA;8D%tfA;8L%HZHBL9ZtH;BvA L
IAI;AtHIAf;uAIfA
IuHJHBL9ZtH;Bwf+f;wH
HAH;tHHAHBHD$`HHBL9Zt H;BvA4HL$ xULI@I;@tHI@f;uAfA
MAfA;8X%tfA;8h%HZHBL9ZtH;BvA L
IAI;AtHIAf;uAIfA
I
uHJHBL9ZtH;Bwf+f;wH
HAH;tHHAH\$PHl$XHt$hH@_HL$ TLI[IsMCWAUAVH@ICISICL-HIKH3B:.$tB:.$HCH{HCtH;CwL3IsȃtIF2HƈHuHKH{HCtH;CwA<vHɃtHJH*FHCHD$pHH{HCtH;Cw*H3HtHFHL$ S\2<(tHL$ S;HCH{HCtH;CwH3HtHF2HӈH<t?HKH{HCtH;CwA<vHɃtHJHOEHHt<HKH{HCtH;CwA<vHɃtHJHEsA)D87tf?tXAЃ	vAvAv	_HCH{HCtH;CwH3HtHF2A:uD87H\$`Ht$hH@A^A]_LI[MCWH@ICISHICHIK3L
}B:
<%tB:
@%HCH{HCtH;CwLI@I;@tHI@u2HˆHuHKH{HCtH;CwvHHAH;tHHAHCHD$`HH{HCtH;CwHHBH;BtHHBu2Ɉ(t-HL$ MQHL$ qM=HCH{HCtH;CwHHBH;BtHHBu2ɈHHS	t:HKH{HKtH;Kw<vHHAH;tHHAHHt7HKH{HKtH;Kw<vHHAH;tHHAyA)D8tl?t^AЃ	vAvAv	_HCH{HCtH;CwHHBH;BtHHBu2ɈA:uD8H\$PH@_LI[IkIs MCWATAUAVAWH@3ISICIKHICHL%D}AfB;&%tfB;&%L{HCH9ktH;CvL3IfA;tM~HfHuHKAHCH9ktH;CwfA+fA;wHHJHt?HCH$HHCH9ktH;Cv-HL$ FL~H3HfA;tL~ff(tHL$ LCL{HCH9ktH;CvH3HfA;tL~HfH-t=HKHCH9ktH;CwfA+fA;wHHJH>HHt:HKHCH9ktH;CwfA+fA;wHHJH>>yf?)tnf9/t_AЃ	vAvAv	_L{HCH9ktH;CvH3HfA;tL~ff)uf?)L\$@I[0Ik8IsHIA_A^A]A\_LI[IkIs MCWAVAWH@3ISICIKHICHL
MDvAfB;
t%tfB;
|%LsHCH9stH;Cv LI@I;@tHI@fA;uHfHuHKHCH9stH;CwfA+f;wHHAH;tHHAHCHD$pHHCH9stH;Cv4HL$ JHHBH;BtHHBfA;uff(tHL$ IVLsHCH9stH;Cv HHBH;BtHHBfA;ufHHt>HKHKH9stH;KwfA+f;wHHAH;tHHAHHt>HKHCH9stH;CwfA+f;wHHJH;
tHHJf?)tuf97tfAЃ	vAvAv	_LsHCH9stH;Cv HHBH;BtHHBfA;uff)uf?)H\$`Hl$hHt$xH@A_A^_H\$Hl$Ht$WAVAWH 3H-HLA:/%t	:/%u:HFHFH9^tH;FwL6I#tIFHAHuHl$HH\$@Ht$PH A_A^_H\$E3HELAA:%t
A:%uBHBHBL9BtH;BwLIBI;BtHIBuAIAIuAH\$AH\$Hl$Ht$WAVAWH 3H-HLAf;/%t
f;/%uFHFHFH9^tH;FvL6I/f;tIFHfAHuHl$HH\$@Ht$PH A_A^_H\$E3HELAfA;&tfA;&uPHBHBL9BtH;BvA%LIBI;BtHIBf;uAIfAIuAH\$AH\$Hl$Ht$WAVAWH 3H-gHLA:/%t	:/%u:HFHFH9^tH;FwL6I
tIFHAHuHl$HH\$@Ht$PH A_A^_H\$E3HELAA:%t
A:%uBHBHBL9BtH;BwLIBI;BtHIBuAIAIuAH\$AH\$Hl$Ht$WAVAWH 3H-[HLAf;/%t
f;/%uFHFHFH9^tH;FvL6If;tIFHfAH
uHl$HH\$@Ht$PH A_A^_H\$E3HɝELAfA;%tfA;%uPHBHBL9BtH;BvA%LIBI;BtHIBf;uAIfAI
uAH\$AH8Lʃ3tmtMt:t"8
A8
8HT$ LD$ IɈD$(|tHT$ LD$ IɈD$(Vq38
돃tNt=t u838
AA-38A3A	A3H8H8Lʃ3tqtPt9t(H8H?HH8H?HT$ LD$ ID$(`sHT$ LD$ ID$(U|3H늃tZtIt+uD3H8H?HI438H?I3IHI3H8H\$Ht$H|$ UATAUAVAWHHPE3EEHL9"tL9bu)nsHCHt	L9cuD 3 Et	A@"wHHMHCHEHHCL9ctH;CwH3H1	tHFAAHE@σx~LEAYHEHHQA#ƅt2HCHCL9ctH;CvAH;HtHG@EA@@-u@+u0HCHCL9ctH;CwH;H~t	HG@AMAG<	w	@ǃ#G<w	@ǃG<w	@ǃtAEEiHCHCL9ctH;CwgL;IЃtUIGHuLEDDHCHCL9ctH;CvAfH;HAt	HG@MAHAEAEDHKHCL9ctH;Cw$B<vHtHJHU3AMc3HIHU8LOЀ	w
DA&G<w
DAG<w
DAAAtqE;slAM;ruAH;v
IIELHCH{HCtH;Cv@2|H;HtHG@HU8AV@2IE3LcHCL9{tH;CwG<vH@A;tLbHS2@uAHEH;CtHCD8D8}tHE؃HCHL9{D8I֋ktzuj"@uMm@t/D8}tHE؃HCHt	L9{uD8H^D8}tHE؃HCHt	L9{uD8H/@tID8}tHM؃HKHt	L9{uD9IL\$PI[0Is@I{HIA_A^A]A\]H\$Hl$Ht$ WATAUAVAWHE3AEHL92tL9ru)ui.oHGHt	L9wuD03Et	A@"wHH$HGMH$HAHGL9wtH;GwYH7HfA;t
HFf;\$XD$`f;r*f;\$hs#f;\$ps
DAAAu-CfvCfvACDfwA AAt~E;syM;ruAI;v
IIELHwHGL9gtH;GvA*HHAH;AtHHAf;tںAHOHGL$L9gtH;Gw!f+޸f;wHHAH;tHHA@u/L;otHGD D8$H$I֋T6S"@uI}@t7D8$tH$HGHt	L9guD HnD8$tH$HGHt	L9guD H7@tID8$tH$HOHt	L9guD!IL$I[0Ik@IsHIA_A^A]A\_HHXHhHpHx ATAVAWH MMHHMtVH|$`H+LIA:+t:u]HGHHGtH;GwH7HptHF2HAII;uH\$@Hl$HHt$PH|$XH A_A^A\2H\$H|$MILMt]LL$(L+HHAA:t:uOIAIyIAtI;AwMI@I;@tHI@u2HAHH;uH\$H|$2H\$Hl$Ht$WATAUAVAWH E3MMHHAMt_H|$pH+Af;+tf;ugHGHGL9otH;GvAL7IUf;tIFAHfAHI;uH\$PHl$XHt$`H A_A^A]A\_2H\$Ht$H|$3IILDMtcLL$(L+fA;tf;u^IAIAI9qtI;Av$MI@I;@tHI@f;uIfHL;uH\$Ht$H|$2HHXWH@LA8HQHLHWHH3@@x蚏HKpLD$XH	@8|$PtHtC@8{2t;HCxHCxHHHu`OUH@D$X@2H\$`H@_HHXWH@LA@HQHLHWHH3@@x:HKxLD$XH	@8|$PtNtI@8{:tAHHHHHuNsTH@D$X@2H\$`H@_HHXWH@LA8HQHLHWHH3@@xrHKXLD$XH@8|$PtEt@@8{4t8HC`HC`HHHuNS
HCh@D$X@2H\$`H@_HHXWH@LA@HQHLHWHH3@@xHK`LD$XH@8|$PtEt@@8{H$H$IWHfE;tHKAHSH$MEuL;t	{4uEtHD$0HChH$H@A_A^A]A\_^]H\$UVWATAUAVAWH03DH@8qH(HAxHAxL@Mu9V?2H
AH(H(HHL@MuW9?2H
AH(H(HA`HA`L@Mu9>2HAh
AH(H(HAhHAhL@Mu8>2HAp
AH(H(HAxHAxL@Mu8Z>2HH
IH(H(HHL@Mu[8>2HH
IH(H(HA`HA`L@Mu8=2HAhH
IH(H(HAhHAhL@Mu7=2HApH
IH(HHLALIHHLALIHHHHD$(HAHD$0HA HHLALIHHLALIHHLALIHHLALIHD$(HAHD$0HA HHLALIHHLALIHHLALIHHHHHHHHLALIHHHHHLALIHHLALIHHLALIHHLALIHH@SH aHH3LAH4DB cHHc c(c0fCCC,H [3HHALAHA8AAHA A(A,A0HHaHLALIMtAHHaHLALIMtAHHaHLALIMtAHHaHLALIMtAH@SH LH3Aa(LADB LI HLc,Hc8c@cHHD$PfC0C2CDHHHCpHD$XHCxHH [@SH LHAJ3Ia0LA LI(DB HTxc4Hc@cHcPHD$PfC8C:CLHHHCxHD$XHHH [HD$(L3ALALI HQ(HQPQ0Q4HQ8Q@QDQHHAXHD$0HA`HHQhHQpHD$(LAJ3ILA LI(HQ0HQXQ8Qss
AEDAA6EtEDA96t"AAAALHLALI E;uEtA>ss
AE|AA6DDACAIDssAEDA`A6@WA>LI^;A63IMtGHu
'0HL;wHEL3T'"
-EEDDLAAAIHLI E;u!A;6I~EHHDEHDAE6HE3HT$0E3HL$8DD$ D$@EF$EuD;F!dDABD$@3EʅEAAstVD;uAAKdDCȉL$@HD$8CEABDDIHЋHCHBTDH ;ƋD$@ut@AsCD;uAdDAAD$@AAËTDHЉTDD$@H څuDD$ AsHT$0AE;	Dd$$D3IAMtEHu
%.HL;wHT$DXL3g%" +D+d$,HRDd$$D$(D+tkAE"tYtWEEtODDDAAAALIHLALI E;uEtA>ssAEDA3A6A6EtEDA96t"AAAADHATH DE;uEtA>ss
AE|AA6HH3iL$I[0Is8I{HIA_A^A]A\]HDLtHE3ED9t(@AAATIAHLʉQI E;uEtAssELAHEIHLD$$D\$ E3ɺs2H̋HAH‰H ADLЋLALLT$D$DH\$Ht$WH 3H9qt2HAqfq@qHq q(@q,q0@80u
y[t3HCCq[H{HK	Z[u2HK%8HA8CHC8*uH@{HCHXDHo[HKIt@HH?HH@IɁ;DA0AEMDDL$ AEىL$$@AHAD$pHH$EtHDHtEuEt[-t%=tDL$ D\$x=u:@7@8$tEu8\$ptADL$ D\$xDL$ D\$xËL$$HHt9AVIHI#HH;9AA+A+A+(IA8^t@H?H@gEAA@rHAAMHAA$HHL$xEtHDHtEuEt9t=t=u"D @A8\$xtEu8$uDAAHIHAVHHH#HH;v%HɁ;~
j~AHHI#HH#It0@ŁHHHH#H4HH
N@ω
3H$H0A_A^A]A\_^]H\$Hl$Ht$WATAUAVAWH0H$DAEALъFA\$?҃A+D;w29vDAE3D9!vA3EAAH HEAE{ECAuFB|ABLH HEAE3EtC|ED"E;uHG|AGlA+AA+EAKIEDCTH#HALI#HLEu
DuAE2E3EtC|AD"E;uAIDH$H\$`Hl$hHt$pH0A_A^A]A\_HE3D8BtAI?LÄAADL	u33ELtAQ
D$t3̸H;vH 3tB 3tBHAHAHAH+HAH+HH\$UVWATAUAVAWH$HpHH3H`
DLEBHL$XHT$pHыIE3DPE҉D$TLJEHA^&D;EEEABD+LHBDT$PHLL$xHD$hA+LRL$0M;:A	EtzEEAATHiʚ;AHLTI E;uLL$xEt6Pss!PDTDPADPEDPDPEthEEt-AAAċTHLቌTDPI E;uEt.AssADTDPADP
EDPEEACAID$HM;EAD$8ȉD$@;ˋG3҉D$<ȋA""A#"HLÍHH
CH "HHLHHuEDPEEELAAATIHLTI E;uEPss$PDTDPADPEDPAATLIDPMt@HTL;wHL3"DPE	EELAAATIHLTI E;uA;DHTELHHDHTIDHL$`EHT$HDEAEDD$DEE"A‹4u!E;EzDDAEʅEAAstfE;uAAJDCȉCEAHHBHCHBDH ;tHT$H딅tNAsE;uADAAAAӋHЉDH څuDD$DAsHL$`HT$HAE;EIDPMt@HTL;wHL3f"zDPtAL$@L^@+L$D;EDG3Dl$8AEA""A#"ًHLÍHH
>H "HHLHHuEDPEEELAAATIHLTI E;uEt?Pss$PDTDPADPEDPADPATLIDPMt@HTL;wHL3L"`DPEEELAAATIHLTI E;uA;DHTELHTELDDEAEHHDEHT$HEAAtu!E;EzDDAEʅEAAsthE;uAAKDCȉCEAH֋ȋHBHCHBDH ;tHT$H뒅tNAsE;uADAAAAӋHЉDH څuAs7HT$HAE;EIDPMt@HTL;wHL39"MDPDd$DDl$8E+&Dd$D&D$RDL$P+L$HL$PD$8DL$0D+t@AIH."uuE3DuLEDHQDE"A9DuLEE3DHHQDAMHxtEtEELAAAIHLI E;uEhss$DDADBE3DuLEDHPHD$pLD$XHAD8ptAI?L0AAD0AUDt$H$tAEuA AL$Dt$HtAȋr+A;DS#|$0Dt$H\$0Ht$8H _3H9̋AËAËA0E3x~{AP~%t;ti	t3ËA(tQtQ;IEII(-t?t6ttt't'I"tt
׺HÊA,HHH̋A0E3x~{AP~%t;ti	t3ËA(tQtQ;IEII(-t?t6ttt't'I"tt
׺HÊA,HHH̊AÅA3QH ҉QH̊ÅA%ÊA%ËA0ËA0@SVWH H>H3H$H
Bu(E3HNE3DT$ LD$$DM?tDEtE3H^EEHfAAHAHHL‰I E;uEtssDDE3DT$ LD$$DH>2gL$D6A~H^LBD
HI>u'E3LD$$E3DT$ DHc>tDEtE3EEfDAAHAHHL‰I E;uEtssDDE3DT$ LD$$DH=2A;L$L$L$HFtLjLD
ELzDLE3H$PAAډL$ EAlu;KDT$L$ EڋE߃stQ;uȍSDT$щT$ LL$$MEALLA	LMEI A;΋L$ uEtCs;uDT$HL$ HT$$HEË
LDL$ I EEustlA;DLD$$IHN<H$PL$L$L$L$H$H36H _^[D2HLu+E3LD$$DE3HDT$ <HÃtH$uH$HH$E3H$EHyEAAËHAHHLʉI D;uH$EtAss"ELAH$H$HEE3LD$$DT$ H7;2̋HH\$UVWATAUAVAWH$HHH3H̉T$(DL%E3LD$,DD$ F&A&EDG3Dl$$AEH< "BL'Bt'HLHL$DD$@B'HL$DHHLHIL$@D$Du
3A6~EEr3M^DDHAAAIAHHL‰I E;uE1Ass
EDAE3ɉt$@LD$DA6I92A6A~I^LAIMtGHu
\0HIwHT$D3AϿ*"u#3LD$DE3ɉt$@A6H
9h_EES3LDDAAHAIHL‰I E;uEAss
EDAE3ɉt$@LD$DA6H82;Mnt
HT$DMD
DL|$DIE3HT$0AAىEfDË
E33H蟗@@
wtmtat+t2g3@8ySH$HĀA_A^_^]H\$UVWAVAWHHHAH3HEHIIMAA;fD{Ht"eHUH
EȉC(HMD38kDLE3I/MH0HM3fCC$HM؋C tS$HMC(tk3DNLEHEAHEIHE蹵tJHc}~
+HcUċMH HHSwAA;v"u͓	2_
FfD{s 3fDfCt,Hd$(HEE3HD$ E33I+tHcEHCAHMH3XQH$HĀA_A^_^]H\$UVWAVAWHHH?H3HEHIIMAA;fD{Ht"eHUHEȉC(HMD3TiDLE3IKMHL
HM3fCHC(HHMHHC HHS(HMHC0Htk3DNLEHEAHEIHEɳtJHc}~
+HcUċMH HHSwAA;v"uݑ	2_VfD{s 3fDfCt,Hd$(HEE3HD$ E33I;tHcEHCAHMH3hOH$HĀA_A^_^]H\$UVWAVAWHHH=H3HEHIIMȑAA;fD{Ht"eHUH	EȉC(HMD3dgDLE3I[MH\HM3fCHC HHMHHCHt~HS HMHC(Htg3DNLEHEAHEIHEݱtFc}uHMwKAA;v"u	2]5nfD{s 3fDfCt*Hd$(HEE3HD$ E33IStECAHMH3MH$HĀA_A^_^]@UHHpH<H3HEHMЅuH uxHUHMtVLE3HUۏtBDUD]L$0DMDEUMDT$(D\$ tuݎ
XHMH3LHp]@UHHpH`;H3HEHMЅu
H uHzHUHM>tWLE3HU"tCDUD]L$0DMDEUMDT$(D\$ fsHu#
e融HHMH3KHp]@SH@HD$xE	EHD$p	DH$DD$\$xD\$pH@[r@SH@HD$xE	EHD$p	DH$DD$\$xD\$pH@[rHD$8E	EDHD$0	DT$8DHD$(DT$0DDT$(ZrHD$8E	EDHD$0	DT$8DHD$(DT$0DDT$(*r̋HHHLAHHLA̋HHHLA̋HËHËHËHËHËHHHLAHHHH@SH H9Ht
H	HH [@SH HH	úH#H [H9Ë	g@SHPHHH

[HcLHHA?IHBD8u	JLKND(3M	u13HL$ DB$UbHCD$ L$0HD$@IA 3HP[@SH`HHH
yZHcLHHA?IHBD8uS	WLKND(3M	u>3HL$ DB8aHCD$ L$0HD$@IL$PA I03H`[̋	g@SHPHHH
YHcLHHA?IHBD8u觊	LLKND(3M	eu33HL$ DB0aHCD$ L$0HD$@IA 3HP[̋		f̋	f̋	f̋	e̋	f̋	e@SHPHHH
YHcLHHA?IHBD8u߉	LLKND(3M	qu33HL$ DB0M`HCD$ L$0HD$@IA 3HP[HHXHhHpHx AVH MIHHV0OLHHσ f^HHt10H%%8"t3E3H3ɉ00^IH\$0Hl$8Ht$@H|$HH A^@SH H9Ht
H	HH [H(H(H("yu=w
菈2H(H(H"Hy~g2HcIH HȰH
H(H\$Ht$WH L3AAuSMtGAAfv
fafwfAx:tDEI@IHEf91tf9\tf9/uf9qt@@fff#иffMte.IvHHtPH-H]t9H*H]t&H'H]tH$H]uf@Ht$8ff8ffffH\$0H _HHH@SH H3҉fAfv
fafw:fy:u,f9Qu^2!fAfw UH [H@SH Hu2`.uHHtHH\t9H
H\t&H
H\tHHs\uH [E3HHtH	Afv
fafw	fz:tAHJHEfD9uf:\tf:/ufD9Bt2H3Hf9AuHfA\fA/fD9	tfD9upfD9ItfD9AubfD9At[fD9ItTHAftHfA;tfA;tHf9t1Hf9t(ftfA;tfA;tHf9tf9Pu2f\t	f/t3øH\$Hl$VWAVH@H1H3H$0HHZE3HI„(軄AHL$ HD0YHHt	蘄($菄8"uQ腄E3H3ɉ(YHHHt2HHfD94GuHtHtH;wAH趲@H$0H3BL$@I[(Ik0IA^_^H9@SH HH	oH#H [@USHHhHUHډM Hu螃!跃3HMDB$=ZEЋEMKC HcU uZ r	txX;`V}PHLTR?HHHID8t-HE U(HELM(HEU0LEHEHU0HM 	躈Hh[]@USHHxHUHډM Hu讂!ǂ3HMDB0MYEMEKC HcU uh 耂	txX;nU}PHLbQ?HHHID8t-HE U(HELM(HEU0LEHEHU0HM 	ȇHx[]@USHHxHUHډM Hu躁!Ӂ3HMDB8YXEMEKMC K0HcU uj 肁	txX;pT}PHLdP?HHHID8t-HE U(HELM(HEU0LEHEHU0HM, 	ʆHx[]@USHHxHUHډM Hu辀!׀3HMDB0]WEMEKC HcU ux 萀	txX;~S}PHLrO?HHHID8t-HE U(HELM(HEU0LEHEHU0HMz 	؅Hx[]@SH HHu	a7Hd$0HT$0WHL$0u
|H2HL$0{H [@SH HHu	
7Hd$0HT$0EWHL$0u
{HHL$0{H [@SH HHu	7Hd$0HT$0VHL$0u
_{HHL$0F{H [@SH HHu	7Hd$0HT$0VHL$0u
{HbHL$0zH [/zH9
tHH;u3H̸csm;t3ËH\$Hl$Ht$WH HE3HHu3HHHHH;t
98tHH;uIHtHxHtHuL@GHHkHspH0HLAHH;u8s8tw8tf8tU8tD8t38t"8t8uOCFC=C4C+C"CCCCHcS׉sHL@GHkH\$0Hl$8Ht$@H _2H(auu	=@t2H(@SHPH<)H3H$@HٹS{LHPHwYLL$@E3HT$@H$4
HH;tHfuA+D$3DD$0LL$0LD$ IDBHT$@|H$@H39HP[H\$Hl$Ht$WAVAWH0Hٹ`3u
=?AH-?AL\HT3Ʌ>L5%?f5&AIA}yAuLVIHHfA94NuHAH̋=̉
=H&HыH3ƒ?HL&HAй@?+HI3E3HALL+IIH;MGMtIHHIM;uHHa&H3@C?HHH
)CH\$WH H/&HH3C?HHu3H{HH\$0H _L%LAй@?+IM3L
BHDuHuHHEHH}@LM@HD$ E3H}H3HbL}@AHUHIHHuKx{8:NHHEHHLM@HD$ AuE@ȉS;HHM;HߋVHU8H}8HRttHM81HU8HHH9:tH@HH98u
;HH:HM8sH}8HsH\$`H0A_A^_^]H\$UVWAVAWHH0ADvqw)}HBAH3fuH5:3H:Htf9>uHHEHH}@LM@HD$ E3H}H3HL}@AHUHIHHuv{8:NHHEHHLM@HD$ qAuE@ȉ9HH9HߋVHU8H}8HrtHM81HU8HHH9:tH@HH98u
9HH9HM8rH}8H}rH\$`H0A_A^_^]EH	H%'uEH	H%/tHHXHhHpHx ATAVAWH L|$`MILHI'IHtLI@2;"u@@"@H7IHtH3HË8tIHtHH@t@u@ t@	uHt	GH@2;; t;	uH;MtI>II$3H;\t;"u1u@t{"uH	3@@Ht\HIutD@u< t;<	t7t+HtHTtIHHtHIHiHtHI%MtI&I$H\$@Hl$HHt$PH|$XH A_A^A\HHXHpHxL` AWLT$03II2IHtLHDA"fD9!uEAAHIMtfAIHftEuf tf	uMtfApH@A\f91f9 tf9	uHf91HtLHHAHfD99tfD9!u7Au@t
fD9auH
@D@MtfE8IIuft/@uf t$f	tEtMtfAIIHrMtfA0II*HtH2HH\$Ht$H|$ Ld$(A_HH6HH
6HHHHHHHH@SH HH	nH#H [@SH HH	nH#H [H	3HH9t
HRHH:uH	3HH9t
HRHH:uHH!HH!HH!uCnCnHHHHH5H5H5H5@SH HH	mH#H [@SH HH	mH#H [H(|H(2@SH HLLH;r3uHHEHH}@LM@HD$ E3H}H3HXL}@AHUHIHHuAp{83NHHEHHLM@HD$ 
AuE@HG3=3HU8H}8HKltHM8lHH}8l?HU8HHH9:tH@HH98u
23H}8H2kHH}8kH\$`H0A_A^_^]H\$UVWAVAWHH0ADvYo8u*H:AH3PmH523H2Htf9>uHHEHH}@LM@HD$ E3H}H3HL}@AHUHIHHun{83NHHEHHLM@HD$ VAuE@H11HU8H}8HjtHM8jHH}8j?HU8HHH9:tH@HH98u
x13H}8Hw1fjHH}8ZjH\$`H0A_A^_^]H
a1H
a1H(H:Hu3H:H(H(H:HuWH:H(@SH Hs:3Hu+H9m:u3ju%H
J:HEHH [@SH H3:3Hu+H9:u3uH
:HEHH [H\$WH 3H9=9t3HpyHHu'HHuH9H93iHhH\$0H _H\$WH 3H9=y9t3CyHHu'HHuHP9HA93hHhH\$0H _3=tHHH€<uHHʊuE3Af=tHHHfD9QuHQHfuH\$Hl$Ht$WAVAWH03L<=tHHH@84uHHȊuHJiHHtlLA86taHHA84.uHA>=t5HiHHt%MHHh3ɅuHI?IgLHI3rgH3fgH\$PHHt$`Hl$XH0A_A^_E3Ht$ E33qH\$Hl$Ht$WAVAWH03Lf=tHHHf94AuHAHfuHJhHHtpLfA96tdHHfA94nuHfA>=t5HhHHt&MHH'3ɅuII?IfM4nH3lfH3`fH\$PHHt$`Hl$XH0A_A^_E3Ht$ E33
pHt;H\$WH HHHHfHHHuHeH\$0H _Ht;H\$WH HHHHeHHHuHeH\$0H _kugvH\$Hl$VH@H56HHd$8AHd$03҃d$(3LHd$ iHctɺH
gHHt[Hd$8AHd$03L3ɉl$(HD$ Sit13H
3dHH>s3H\$PHl$XH@^HdLH\$Hl$VH0H5B5Hupsd$(AL3Hd$ 3eHctغHLfHHtKLAl$(33HD$ et-3H`3=dHH>u3H\$@Hl$HH0^HdkMHH	
eMHH	銛HHH<uHHHfu.H@f.LȍU@LH;teu*H@ssf_tmHLLÍU?:t6uJHsDftf,u9HLLú:uyf,fI^0H\$PHl$XHt$`H0A_A^_E3L|$ E333YE3L|$ E333XE3L|$ E333XE3L|$ E333X@SH {DAЀɃt6t9t tR?XAAD
	AH [H(HHH;LDH~AJAHB A@ J0AH0B@A@@JPAHPB`A@`MJpIAHHuAJAHB A@ J0AH0B@A@@HBPI@PakyH(@SHPH@H3H$@كw:Ht5HD$0D$(LHD$ 3A3NtHT$0z3H$@H3"HP[@USVWATAUAVAWH$HHHH3H0L3HT$HIH\$XMLHHu%3H0H3HHA_A^A]A\_^[]iHAUt$0HHL$8LHHHL$@LIHD$P7f?Cu0f9wu*LHIPMtA6ITHHE3HfD9wuHsLLIM+B+uHuHD$@LL+B+uHu{Kz3HDHL$`Au}ELD$`L|$8HL$`It'`t[LD$`I>E3MHHfD9;AJLHL$0Mƺ-#HH=
LD$0fDl0AHHtI^fD9+tHfD9+HtH$H3H$XHA_A^A]A\_^]3Ll$(L$@AHD$ UHT$0HtHtALw(t@IHD$0H+DA+u	HEutLD$0HHHuAI ~=0I8CE3Ll$ E333KH\$ UVWATAUAVAWH$H0HH3H ILcH莗LpAHT$`HLHD$@HD$(HD$ UvE3Hu,3H H3uH$H0A_A^A]A\_^]IHL$`HHD>(LL+F	A+u	HEutHD$`HHfD9XuH]@LHwHL>(LD$`HL$HHSJ(HL$POL$DHHw3ۅf|$`CIEHD>(uf9\$bu
J(HpJ(AD$@DÉGHIO A9GtIAIHHH|EtIcIIIAu|GEHzD$0LAD$(AQHEp3HD$ )it@HMpf!HIHcHrHHMpA2˅AOA_GAAGGAu	D$@G
AuD$@GKdHHHDH3ۅt8HD$HHD>(J(>HD$PIJ(>D$DGH
H9L$Ht?HD>8u.HL>8N>HL>0D>J(7>H\>(J(AEHD>(Ll>8SE3H\$ E333GHHH
3HH
H
HËH(vzA3G
tH(HiH
@ƒ?+3HH3Hl=H\$LL$ WH II
H6H\$0H _H\$Ht$LL$ WATAUAVAWH@IM
IHHu	H@H5oDA?HH3:AHH|$0HH3ZHH\$ HGHLH|$(LH\$8A@AA+3HH3HH\$ H;rH9uH;sJHH;tHg<H5ƃ?D+A3HH3IHHIHHQIHHQr΃?H33HHHCBIHH5DA?LL3
AIHBH3HM;uI;t MLL$(ILL$0LHD$8HHD$ H$3ۋ~H\$pHt$xH@A_A^A]A\_HH(HLHH LHP HH?H(HH(HLHH LHP HHH(LHAй@?+HI3HH̋HHHLA̋HËHËHHH@SH HH	:H#H [H\$Hl$Ht$WATAUAVAWH H3LH8HuH7LHI3I3EA?AHHHFHLLA@AHA+HI3HH;raH9tHAI3HHHM@LIEA?AHLHBM3I3IHM;uI;tMILHHtH9LLA?D+IAHI3HH)IHHiIHHi3H\$PHl$XHt$`H A_A^A]A\_̋	i|HHXHhHpHx ATAVAWH H3LHHuLA@H+ALK?H[I3M3HI3IHL;H+ݸHH;HHGAD$HHDH;rED$HH3L8Mu(H{AHH~3L8MQLMAI?A+HHHI+I3HIHIL;HGHtHHHIH;uLAÃ?+IGHAHI3MAIHʃ?+IHH3HH)AHtƒ?+IIL3HLBHVƒ?D+IAHH3H3HYH\$@Hl$HHt$PH|$XH A_A^A\̋	z̋	)z̋	!zHH!@SH HH	c7H#H [HH
BHH
}LIKH8ICICMKMCIS D$PIKD$XH8E3LHuHAH9u$Ha@ƒ?+IL3MMHMH3HT$HL$UHH@HEHELM(HEHELEHUHM E(EH@]HHJH(H
1TH
=HH(̰̰H(H(ð̰@SH H@3ۃ?+HH3H>H~HHHSH [3
@SH H
OuH
<H
H;t5H$H
u|5H
q3H`g5H
dHUT5H
YHJA5HDH [̰E3HALL+IIH;MGMtIHHIM;uHuH
~{H(HH(H(H(H=H
FU|H(裌H(HyH6HEAH(H
5HxHEHHH(@SH HHH5HzHEBHZH [@SH 轊HXHt
HG:5LMtHT$(vHT$(gHHtt;t+؀|$8tHD$ 3H\$PHl$XHt$`H@_HdHHXHPUVWATAUAVAWH0LLHE33LhHH'Eut=AwHt$pHtm3H)u3H#2IILƄt6<"uIMIAuHtH+II3HHu*31IH1Ht^3H跕uPHgHHD8.t"tIID8(uD)313H{u3x1Hp1H'H=3HRtH=ߍHG1IHMtLIG8,33LÄt8<"uHIHAuHtH+ʺH$,HHu)3=*3H3*HtS3HuEI.d;t"tHHǀ?u3)3Hu3I6)H&H=`3HuI>
HJI3H)H\$PHHl$XH0A^_^Hd$ E3E333Z3HHXHhHp WAVAWH0LLHE33LxHH5t/AH\$`HHtr3HXuII>IILft=f"uHIHAfuHtH+ʺH*HHu*3(IH(Ht[3HuMI.lfD9;tf"tfHHfD9?u3fD8u(3H裋u3I6](H'H=3HuI>
HτIIH)(H\$PHHl$XHt$hH0A_A^_E3L|$ E3331H8Hd$@L3HL$@觉t	t3HD$@H8Hd$ E3E3331H8Hd$@L?3HL$@{t	t3HD$@H8Hd$ E3E333;1H\$WH H3ۋӋLNJtW<"uHIHAuHt>H+ʺH(HtH"tHH8uH3&H3H\$0H _H\$WH H3ۋӋLftcf"uHIHAfuHtEH+ʺHl(Ht$Hf"tfHHf9ufH3d&H3H\$0H _̋A̋y̋H	.̋H	b̋H	̋H	J̋MH	鯈̋H	颈̋MH	铈̋MH	̋H	̋MH	HHH<uHHHfHT$(HT$(HDžt;t+؀|$8tHL$ Ht$XH\$PH@_@SHP3Hu%+L$`d$xd$@d$0DD$(D$ @DLHT$`HL$xD؉D$@|$xt0t#HcL$`HHHd?HH€d8L$`tB%uD$`HP[@SHP3Hu%*L$`d$xd$@d$0DD$(D$ @DLHT$`HL$x؉D$@|$xt0t#HcL$`HHH?HH€d8L$`?t$uD$`HP[H\$WHPEL3H$HuO$*3Htً$tAtd$@d$DL$0DL$(DT$ DHHL$@	D$D|$@t,t!HcHHH?HH€d8ZtH\$`HP_H\$WHPEL3H$Huo#')3Htً$tAtd$@d$DL$0DL$(DT$ DHHL$@	D$D|$@t,t!HcHHH?HH€d8ztH\$`HP_HD$8E	MHDHD$0H	DT$8DHD$(DT$0DDT$(<HD$8E	MHDHD$0H	DT$8DHD$(DT$0DDT$(8	HD$8E	MHDHD$0H	DT$8DHD$(DT$0DDT$(HD$8E	MHDHD$0H	DT$8DHD$(DT$0DDT$(LI[IkIs WAVAWH0Lc3MAA?H
IIHIAHHBD8A@Eu"IK\$PD$PA#u?A#A@t>tt u#;uD>E@zE#‹ˋ=@t=t3;VEKA;vv\8A\$PHT$PA~DtEA;tW|$PuDE3A誉HtzE33A蘉Hu1 MvD$P=u
 =uE3IAMHtD>E33A5HttY\$PtuD$PAD$P~(DHcHT$PD+HAaF;3H\$XHl$`Ht$hH0A_A^_E3H\$ E333[%HHA@MA@LHd$0D$(A@E@ARD$ HHH(DtHt!t$.'A"%@H(H(#tetVtGt8tEt!t';tf$!H(H\$Hl$VWAVH0HEAtFt t#-&"%@C#t^=tP=tB=t4=tB=t=t&;tx1#!CtJt>t2t&@t'"&3{@	3c@sC@tu@uHL$Xu9t$Xt@+t8A#@uC@@tkkKs	K
sk@ tk@tkHl$`HH\$PH0A^_^Hd$ E3E333<"H(tKt?t3t'@t!$3	3H(H8s2H8@tHL$@u
|$@Hd$ E3E333!H\$Ht$WH HcH
_HHH?HHL8HuxytAH舄HHu8tMF3HT$0ft$0DF^uf|$0uH׋~tE33ҋ+Ht3H\$8Ht$@H _HĉPL@LH H(H@DH(LECMK SH@d$(MKIC MKD\$0L$0EˋH@[HHXHhHpWHPH`HHHPIAuC$DH\$@H։D$0LË$H͉D$($D$ HˋH\$`Hl$hHt$pHP_H8AD$(DL$`ELHL$ DAIH8HĉPL@LH H(H@D2H(LECMK SH@d$(MKIC MKD\$0L$0EˋH@[{HHXHxL@UATAUAVAWHhHEMDMwHDEoHAHMfsfI~I L}E@EEAuw GPuT iHd$0LM׋MAHUEHeH]H ]\$(L$ IH EEH]DuHELHA#;uFAt@Hd$0LM׋MADuEHU\$(L$ HM_H MHELHu3HcL=H?HHIǀd8IuQȋHcL=GHʃ?HHIπd8I_
~]u@uIHcL=HH?H]ILj\8HcH?HHID9At+Du3LmELMMHUE)EEMtDbAHcEHʃ?HHIψD9HcHƒ?HHIA$d=D=Hu AtHcH?HHIǀL8 A#;AIHMLMHd$0ADEL$(ML$ HM_DuHUH 6HHu3HcH?HHIǀd8_HcH?HHIHT(3L$I[0I{8IA_A^A]A\]H8AD$(DL$`ELHL$ DAI[H8H\$Ht$WH0HHu3H\$@Ht$HH0_HHÀ<uHK%HHtLHSHuHHd$ E3E333H\$ UVWATAUAVAWH0LcLIHP?MIHJHL8(H$Mt
A>
uL88d88O$IIM;In<<
tHHHI;s}
uH
HH
Hd$ LL$xAHT$pHHtf|$xt_HJD88HtL$p
uM
JL8:@|$p
u
I;u
,AHA||$p
H:tH/
HH$I;JD98@uD98HI+ދH$H0A_A^A]A\_^]@SUVWATAUAVAWH8LcLIMI?HLA
KHL8(H$Mt
fD9
uL88d88N$BHHI;Hj
fnf;tfHHHI;sfD9MuHfDHH|fHd$ L$AH$HH$LA
KD88Hte$fA;ufD
H$I;7
f$f3KHψD:HH|KDL89	H(̋	H\$WH Hu3UHu	@u
;u@xtHH;tHuH\$0H _̉L$H8Hcуuo 	txX;usPHLi?HHHID8t-HD$@T$PT$XLL$PHT$XHD$ LD$ HL$H 	
H8H\$WH HcHu3WHu	@u
;u@xtuHhH;t\Hu؋HLz?HHHID8t3H\$0H _HHHHH\$WH H?HuJH
\,3HuH3+VHHHtHCHH
H\$0H _Ht7SH L3H
uHH [@SH HHwEu0w
Eu$oAA$us@HHCEtHf9+tEuf93GAHKHHHf9+tf;=Hf9+tAHKH}\u
H
/JAHrKHZ\u
H/'AH_KH7\uH/Hf9+t8H\$@HHl$HHt$PH0_H\$H|$LL$ UHH`HAHMz@E؉Eu3`DEHMDD$ HuHM(E	AHE(`HE(H`(HE(H`HE(H EHM(AHE(H\$pH|$xH`]H\$H|$LL$ UHH`HAHMf@E؉Eu3`DEHMDD$ HuHM(E	AHE(`HE(H`(HE(H`HE(H EHM(AHE(H\$pH|$xH`]MH	MH	EMH	鹸MH	魸MH	顸MH	IZMH	=ZMH	1ZHD$(E	EHDH	DT$(6HD$(E	EHDH	DT$(̋@t2Ã@)̀:t2	̀:t2	 ̋t2‰̋t2̀:t2ì:t2q̀:Lt2uIAHËt2HHXHhHp WHPHIHHA3@D$0D$8:tGDD$0HL$pDD$ Hu&D$4	GD$p_H_(H_HH߉GHl$hHH\$`Ht$xHP_HHXHhHp WHPHIHHA3@D$0D$8:tGDD$0HL$pDD$ Hu& D$4	GD$p_H_(H_HH߉GHl$hHH\$`Ht$xHP_H\$WH H_HH3?HHE33HHH\$0H _HH%@ƒ?+3HH3H\$Ht$LL$ WH II؋
,HLHƒ?@+IL3LSH
L>LAЃ?+ڋ3HI3HĻ,H\$0Ht$8H _HH(HLHH LHP HHGH(HIHыH3ƒ?HL1HAй@?+HI3̋HHH̋HHË	+@SH LHA@?+HHHH
QI3HS6LAЃ?+3ҊHI3HH [Ë	*@SH LsLAл@?+IH
M3ȍSL
zL=AЃ?+3ҊHI3HTH [HL
I3LIHIL
ILIHIL
ILIHIL
ILIHVeL
ILIHNEL
ILIH>%L
IL}IH6L
yILeIHfIL
qIL]IH^IL
qI	L]IH^IL
iI
LUIHVIL
qIL]IH^IeL
yILeIHfIEL
yI
LeIHfI%L
qIL]IH^IL
mIL]IH^IL
yILeIHfIL
qIL]IH^IL
yILeIHfIL
ILmIHnIeL
ILmIHEL
iILUIHVI%L
ILmIHnIL
IIL5IH6IL
aILMIHNIL
aILMIHNIL
aILMIHNIL
YILEIHFIeL
IIL9IH6IEL
=IL-IH.I%L
9IL%IH&IL
9IL%IH&IH\$Hl$Ht$WAVAWH HHH;L=7IHtHttmM,3IAzHHu <WuE33IYH3HuHIHIHt	HHu(HH;j3H\$@Hl$HHt$PH A_A^_HH\$Hl$Ht$WATAUAVAWH DL=MILK0LHAIH3у?HH;%HtHM;uIHtH;tzsM,3IARHHu WuE33I1H3L=cHu
HIHIHt	HXHuUHI;dL3HtJIHHt2L@Aȃ?+ъHHI3K0-LבLΑA¹@?+HI3K03H\$PHl$XHt$`H A_A^A]A\_HHXHhHpHx AVH L5rI3Ht
HH;HDsI,3HAHHu!WuE33HHHHuHI3HIHt	HHH\$0Hl$8Ht$@H|$HH A^HHXHhHpHx ATAVAWH IHLI;L%7IHtHttmM,3IA"HHu WuE33IH3HuHIHIHt	H.HuHH;j3Hu3IHH\$@Hl$HHt$PH|$XH A_A^A\@SH 3AHmHu!2WuE33HH [H%I3H [@SH L
GA3L:AH;A*HHtHHH [HH [HHXHhHpHx AVHPAIL
@LL@H@HHtWHH$DH$LHL$@H$HL$8H$HL$0$L$(IHD$ 23IDϋ$LƉD$(H$HD$ H\$`Hl$hHt$pH|$xHPA^HHXHhHp HHWH@IIL
%@L@H@HHtHHL$PLLƋ0HD$PHD$0LL$$LD$0HT$(D$$HL$ D$(H\$XHl$`Ht$hH@_H\$WH HL
?L?H-HHHtHXJH\$0H _H\$Ht$WH HL
>HjL>-HHtHHӋHӋH\$0Ht$8H _HHXHhHpHx AVH@IIL
>LLr>Hs>	HHt7HH$LHL$0LƋL$xՉL$(HL$pHL$ I,3ILϋD$xLƉD$(HD$pHD$ H\$PHl$XHt$`H|$hH@A^@SH L
=
L=H=HHtHHH [HHHXHhHpHx AVH AIL
=LL=H=HHtHlDLƋI
xZ3H\$0Hl$8Ht$@H|$HH A^HHXHhHpHx AVH AIL
l=LLZ=H[=
HHtHDLƋI3IwDLƋH\$0Hl$8Ht$@H|$HH A^H\$WH HL
=L=H
=HHtH_H	HH\$0H _HHXHhHpHx AVH0IIL
<LL<H<%HHt*HL$hLωL$(LHL$`HL$ I,3IuLϋD$hLƉD$(HD$`HD$ SH\$@Hl$HHt$PH|$XH0A^H\$Ht$WH L
H<HH><L*<yHHtHDH
E3DNjHYH\$0Ht$8H _H\$Ht$WH HL
#<HH<L<HHt$HHHHH\$0Ht$8H _HH\$Hl$Ht$WH AL
;L;HHHHtH`DŋHH9H\$0Hl$8Ht$@H _H\$WH HL
p;L\;H];,HHtHH3HȺH\$0H _HHXHhHpHx AVH EAHL
+;L;H;HHtHxEDH׋
DH׋4GH\$0Hl$8Ht$@H|$HH A^HHXHhHpHx AVHPAIL
:LLv:Hw:!HHtWHH$DH$LHL$@H$HL$8H$HL$0$L$(IHD$ 23IDDϋ$LƉD$(H$HD$ ,H\$`Hl$hHt$pH|$xHPA^H\$Ht$WH L
9HH9L9AHHtHHHFH\$0Ht$8H _H\$Hl$Ht$WH IL
9L9HH9HHt+HLNjHHH\$0Hl$8Ht$@H _HHHXHhHpHx AVH AIHL
39LL!9H"9THHt5HDLHIHH\$0Hl$8Ht$@H|$HH A^HBHHXHhHpHx AVH AIHL
8LL8H8HHt5HDLHIHH\$0Hl$8Ht$@H|$HH A^HH\$WH L
a8LQ8HN8]HHt
H(H\$0H _@SH L
/8L8H 8HHtHH [H\$Ht$WH L
 8HH8L8HHt#HHHH\$0Ht$8H _HH\$WH HL
7L7H7lHHtH7HH\$0H _@SH L
6L6H6#3Ht'L
6L6H6KHtH [H(L
4L3H3HH(H(L
U6LA6HB6HH(H\$WH L
3L3H3cHHu3MH*HHtL
Y4LE4HF4%HHuHHHH\$0H _H|$H$H=M¹@?+3Hȹ H3HH|$H\$WHPHH3HD$@L
3L3H3HHuvL
U4LA4HB4aHHtH,HHu283HHD$0D$8
Hd$ LD$0AHAQׅtʊD$8$HL$@H3qH\$`HP_H\$WH L3ۅt\L
_2LK2HL2HHt(Hȉ\$0z3HL$0׃zu
H

2H\$8H _@SH u/HHHtHtH#HHH;uذH [H\$WH0d$ _\$$;tnHcHHHuUH
tH
vHY4tD$ H]HH0oH
HHKH8H$놹)D$ H\$@H0_HL$HAHHD$`HH#;LDAA
HA@A#AHuH\$Ht$WH HًA$<uJAtC9+yaHqH1~/DH(u;t
KCtc3H\$0Ht$8H _@SH HHu
H [@ktCtH }@u3H [̹HHXHpWAVAWH@``|H=ēHcL4AH|$(I;tqHH\$hH\$0HuWH1C
t<uH+A;t*D$$$u CtHT$ A;AD׉T$ Hl1H녹4D$ DD$$H\$`Ht$pH@A_A^_H\$HL$WH HHu
1HH1H\$8H _H@@SH HًA
t'AtHIc3HCHCH [ÅttøøHHXHhHpHx AVHHH"E3fD9t$bHD$hHHcHp H98L8;=̡O=št^AH;tEH;t?t:u
HOt(HH?HHHHHHA(A8HHHHuL$I[IkIs I{(IA^H\$Ht$H|$AVH 3E3HcH
 HÃ?HHHHC(HHv	K8C8υtt
HHHHvHf3tHs(uK8@.u)K8#K8@HC(HHtI@I5H\$0Ht$8H|$@H A^@SH 33?uIH [H\$WH 3H=H;Ht
諧H$;HHrٰH\$0H _H@H(HuoAH(@SH E3HtHt	MufD{3H [LL+CfAMIftHuHufD;"3@SH 3Ht
HtMufH [LL+CfAMIftHuHuf"@UH Hl$ HxLɃL AI+IML#I;LBI
9tHH;uI+I;uILIM+IL+LWt	u	H I;uI9tHH;uI+wHH+HIML#I;LBK
L;t
9tHH;uI+I;uLIM+WIL+Lfoftfu	HI;uI9tHH;uI+eHIL;t
8tHH;uI+H ]@UH Hl$ H+wLLt)HQHH;tE3fD9
t	HH;uH+H H+HML#II;LBE3IKXL;tfD9
t	HH;uI+HI;uPIIPI+HH+WLJu
u	H I;uKP
fD9
t	HH;uI+HwHt+HQHH;8E3fD9
+HH;uH+HML#II;LBE3IKXL;tfD9
t	HH;uI+HI;tIIPI+WHH+LJfofufu	HI;uKP
fD9
t	HH;uI+HQIL;tE3fD9t	HH;uI+HH ]LHI;t
8tHI;uH+LQHI;tf8t	HI;uH+H@UH Hl$ HLLA I+LIML#II;LBIL;t
8tHH;uI+I;uJI+JHƒH+HWtu	H H;uK9tHH;uI+wHH ]@UH Hl$ HLLt)HQIL;tE3fD9t	HH;uI+H H+HML#III;LBE3KXL;tfD9t	HH;uI+HI;uSI@II+HH+WLJuu	H I;uKP
fD9
t	HH;uI+HwHH ]LLAI+LIML#II;LBIL;t
8tHH;uI+I;uJI+JHWɃH+Hfoftfu	HH;uK9tHH;uI+HLLt%HQIL;tE3fD9t	HH;uI+HÃH+HML#III;LBE3KXL;tfD9t	HH;uI+HI;uSI@II+WHH+LJfofufu	HI;uKP
fD9
t	HH;uI+HHw@UH Hl$ HotH ]@UH Hl$ HouH ]foftfofuofof@UH Hl$ HWH ]W@UH Hl$ HwqLɃL AI+IML#I;LBI
9tHH;uI+I;LIM+IL+LWt	u	H I;uI9tHH;uI+wH+HIML#I;LBK
L;t
9tHH;uI+I;u^LIM+WIL+Lfoftfu	HI;uI9tHH;uH9tHH;uI+HH ]@UH Hl$ HpLLt+HQHH;E3fD9
HH;u H+HML#II;LBE3IKXL;tfD9
t	HH;uI+HI;HIIPI+HH+WLJu
u	H I;uKP
fD9
t	HH;uI+Hwt+HQHH;E3fD9
HH;uH+HML#II;LBE3IKXL;tfD9
t	HH;uI+HI;usIIPI+WHH+LJfofufu	HI;uKP
fD9
t	HH;uI+!HQHH;tE3fD9
t	HH;uH+HHH ]@SH 3HiE3HHʺtRÃ
rӰ	3$2H [HcHH"HH%G@SH HHH/
u߰H [HcHHΓHH%H
YH%H
IH%H\$T$UVWATAUAVAWH03LHugH=H軏LHt^I;tY@8pL5@L;5@l$puIiLHߌAMtPH95͌tGYHHHH$H0A_A^A]A\_^]@uѺI讽3HaȻL5UMuHH95Ku+Ix3H3蒻H95'tL5MtMIM+I96t4HMI!1uHA<=tA84t	HH93I+H
I+HHHxWI96tRI@uM<IDIHI94uAHI)3HHtfHk]@HHSH;s	HHH;sAI3L萺MtMgI>HtVLHVVu0HH?u3=HH\$@Ht$HH|$PH0A^蟷Hd$ E3E333胷HHXHhHpHx AVH03HHu3HHH9/tHH@H9(uH芷HHt{H9/tQLL+HHHf9,puHNY3I>vI>HtYLHVu4HH9/u3MHH\$@Hl$HHt$PH|$XH0A^誶E3Hl$ E333菶H\$Hl$Ht$WH H=HHHH?t4HLH*uH<=t<t
HH;H+H
H+HHHl$8HH\$0Ht$@H _HHXHhHpHx AVH H=E3HHHL97t5HLHE(uHfH;HH#HAH;w
HH_H+H\$@HH;HH#E3HHtHIHI3LEtt$(LEH\$ FLD$0LEt$(H\$ 蝵LE3M9vAII$fI$IʅHK9uLuAL]DfEdM9AAHHAMfD9tA;h+A'A;AC;tEC!A;tdAC&;t%AC:;HHojuXHw
it%t#tAAbAڸmt
tAAHHjuHwp%}	A+ƒA…uFJ-3HׅtIIB<uHcIH5_>-Hu-HW~BHHD$8HH
3L
8$HHH+HHH/HD7qHKEtEHF80tWDFAyAC-Ad|QASkœDA
|gfffASkDDC$u90uHQAE^|$HtHD$03Hd$ E3E333JyLI[IsWH@t$x3H	IICMCICHHD$pIC!DD$4LL$03H׃|$0-DH+HHDH\t%H$LL$0HD$(DHD$ HH\$PHt$XH@_HHXHhHpHx AVH@HT$xHHHMA@ANɀ|$pt;u3HcA>-Hf0A>-u-HHA~$LIB<uIHKH\0HIcFH؅~|HkLIB<uIHH\HD$(HHANyB|$pu;}߅tHƀ<.uHcLFHHd\LcǺ0HH|$8tHD$ H\$P3Hl$XHt$`H|$hH@A^LI[IkIsAVHPH	3ICIICMCH$H$IC(Dt$DLL$@D$3Ƀ|$@-HAH+HH1HDHWtD$DD;|E;$}H\$Hl$Ht$WATAUAVAWH`MIHLHu^ntMtMtL$Mtы$At
CvE2AH$@u*Qt!ILH?LƀDt$ sHA)tXt
tL2=AHUEDmE4fHt)I;AHMHHAHHMHd$8HEHd$0LEMAD$(3HD$ H1bDHMLMHd$ HUDSb3҅tkK+MωKD9urbA
u4HMЍB
HT$ DBHUfELMb3҅t,}r.CCI;KD1>KL0=C\`HHMH3H$HĀA_A^A]A\_^]HHXHhHpHx AVH 3AHHAHHH;sEDp
7f;u)Cf
uAfA;uCCHH;s
_Hl$8HH\$0Ht$@H|$HH A^H\$Ht$WH Hcًu2ZHH5/H?HHD8tβHH8uH|9tHHT$8HL(`H\$0Ht$@H _H\$Hl$VWAVPtIH+HZH3H$@HLcIAHH
x.A?I#IcHcINt(L;soH|$@H;s$H<
u	C
HLjHH$?H;rHd$ HD$@+LL$0DHT$@I_tD$0C;rH;r4^HH$@H3L$PI[ Ik0IA^_^H\$Hl$VWAVPlHH+HRH3H$@HLcIAHH
p-A?I'IgHgINt(L;H\$@H;s1Hf
uG
fHfHH$>H;rHd$ HD$@H+LL$0HHT$@ID^tD$0G;rH;r]HH$@H3L$PI[ Ik0IA^_^H\$Hl$VWATAVAWpLGH+H2
H3H$`LcHIEHH
P,A?MIMIHNd(3#HCM;HD$PI;s-Hf
u
fHfHH$H;rHd$8HL$PHd$0LD$PH+D$(U
H$HHL$ Dȹ34]tI3t3Hd$ H$LL$@DHID+I]tt$@;r͋A+ljCI;3[HH$`H3BL$pI[0Ik@IA_A^A\_^H\$Ht$L$WATAUAVAWH ELHcكu[ [	xt;.slHLIL-*?HKDL08tEq7KDD08u[	j[ EIԋ@8F[ ^[	aH\$XHt$`H A_A^A]A\_H\$ UVWATAUAVAWHH`3ELcHEu3HuZ8Z`wMH)A?MIILmJB\19C<w	AШtBD18 t3ADBAH}VH)JBD086HH98uHS)JB8|09H=)JHUJL1([t{ˀ+!}N$>3L]I;	E/AfA;u3]fA
uA
AfA;uÉ]IM;sXELmEHMLAxH~(JBD18tM˄t2tuyEHMLAEHMLAEHMLAkJL1(LM!}3H!D$ EHHEYu	HXEЋ}EEHEH uhEt-uX	XM=XH'JBD08@t	>{X\X E+H$H`A_A^A]A\_^]HHXHpHx HPUHH HkHUDBAuX	HEHHEHAAt
W"HEHAt+HE`HEHHEAtHHHHE`HEHHE`HE`HEPu8H]A
H;tH]H;uu	HMHU@]!@H\$0Ht$@H|$HH ]HHXHpHx HPUHH H3HUDBAuV	HEHHEHAAt
V"HEHAt+HE`HEHHEAtHHHHE`HEHHE`HE`HEPu8H]AӶH;tH]H;uu	HMHU'H\$0Ht$@H|$HH ]HHXHp HPHWH HHL$8LcȋQHL$83ۋHA9H+yHHD$8H ɉH~)HT$8DAHRLHD$8;HHD$0lAAvIHH$?IHHHH
]A8 t3ADBmHuHL$8IAHT$0AH\$@Ht$HH _HHXHp HPfHWH HHL$8LcȋQHL$83ۋHA9H+yHHD$8H H~+HT$8DAHREHD$8;HHD$0flAAvIH?#?IHHHH
TA8 t3ADBdHuHL$8IAHT$0AH\$@Ht$HH _H\$Ht$WH HHDCAuS	KCt
|S"׋CtcCtHCHcKccCu,γH;t迳H;uuHH@$_@H\$0Ht$8H _H\$Ht$WH HHDCAuR	KCt
R"ՋCtcCtHCHcKccCu,H;tղH;uuHH>]H\$0Ht$8H _H(迤HT$0HHL$0HJHD$0HH(HH\$WH f;u3Jf;sHH+3fL$@LL$0f|$0HT$@ODPtD$0#H\$8H _ËRuHHcH#E3Ht$H|$Lt$ UHHHH3HEDHcIHMҽG=wHEHyHU@.t@uDJ@}E@}DE3T$0ELEfEHEЋHHEL$(HMHD$ vu8EtHEȃ3EA#ƀ}tHMȃHMH32L$IsI{ Ms(I]HE3HALL+IIH;MGMtIHIM;uE3HALL+IIH;MGMtIHIM;uHH)$pH$3$$H$H$H$H$H(HuROU
~$3H(H(Hu"OT
R$3H(H(HuNT
$3H(H(MLHtFMtFHtHt9Aw3H#IcLHHA<uHHMu&3H(MtqN*TH(I;v
"H(L#IMIH(sKHdJDAAQ+AADAAAADɋD+ʙAH\$Ht$WH HI3HHtHHdHEHH\$0Ht$8H _H\$Ht$WH H3HHtHHHEHH\$0Ht$8H _H\$WH HHHu2MRnA$#HtLcA@W}LH&AL;y-2AAi€yFD3D;|&AD+D;|D+AӸD;|AD+AˉSLE.EAAi€SDH"LEIJEHI9|E+˸E.DKIcA+S/$Ic ʃk+ȸųAKAiSDAAkHHt$LD$8L
)HHL$@4uH33H=HH\$0H _H\$UVWAUAVHH0H-E3HM8Du8HDu@~HM@
H
Ht&LHL+FA+uHEuWj=HHHD84uH=3HeD=H
YHHD84;uHWL#>:HDhE͍P@LA/D83t	HHu;-@@tHHBiU8<+t,0<	wH;:uLHHBU8k<щU8<9	HÊ<0};:u"HHBU8ЉU8<9	HÊ<0}@tډU8D83AE@tHNMLú@i
t	,HFD0]8x]@^H\$`H0A^A]_^]E3Lt$ E333EE3Lt$ E333EE3Lt$ E333EE3Lt$ E333EE3Lt$ E333wE@USVWHHH3HM(u(H؉u0u88HM0iHM8CH
_>;H
kH5Ln>k
Nt9u@u	H@p?H@0HE@AHD$8LHC3Ht$0D$(?HD$ >t9u@u
HC@p?HC@0](z]0`]8^HH_^[]E3Ht$ E333CE3Ht$ E333CE3Ht$ E333CH\$Ht$WH@H3H3H$0L
3A5HT$0HL$ 蕛uH|$0N"tHDHL$ 9HHu	3C9LD$ L
AHHL$(LtH39HD$0HH;HDHt@87t
HTH8H$0H3L$@I[IsI_H(u)HN{us{H(@SH Hٹ{HعT{H [H(zx-{H(HT$LBIL9sztHcB HrLHT$BHHtf9tHHfHD$@HD$`HD$HH\$Ht$ HT$UWAVHH@HH3HEfMHnt=HM(wnt/H](HfnHcL5 
HHPn?HIH0@933ɉ]]Mu)DDCHUHMt
DEEAEDE@uHE(IcLHLL9s9XuD;@ LHE(DEAHHcхxHHDHHE(yDED@HE(`HE(HEHMH3;H\$pHt$xH@A^_]HHXHhHpHx AVH Hf;BROuHuHHGu_Hlt8Hlt+HlHcL5HHl?HIH@8t
H`HGHHH9suJHcG Hr@HGHtHHf9(tHHHHf(GgOH\$0Hl$8Ht$@H|$HH A^H\$HT$WH H3Hu8w>"HHpHH\$0H _H\$WH BHڋu}HkLcHLJAIvMIA?HIMLAx9u$AAvII?HHIB=t7=ltCKuuH{uH@HH;Cu{tHHCHHt
@88tHH@8CcK@H\$0H _H\$HT$WH Hڋ3HuG7=HHӋHvH\$0H _H(##t$=t=t+H(H(%H(HHHHXHhHpHx ATAVAWHPE3ILHAHtMu3fD!Hu]6Cfwf Afwf Hft9f;t2HT$(THT$(Hv@Hftf;t+@8l$8tHL$ H\$PHl$XHt$`H@_H\$Hl$Ht$WAVAWH03HHHu(-3Ht>E|$(DH>AH|$ AAL3g%Lcu'S'IH2$HHt=Dt$(ALHD$ 3A"%u&'HHHH#H\$PHl$XHt$`H0A_A^_H\$Hl$Ht$WAVAWH@3HHHu"',3HtFDH|$8DH|$0Alj|$(AH>AH|$ L3]'Lcu&Q&I3#HHtGH|$8AH|$0LDt$(3AHD$ 'u%&HHHH"H\$`Hl$hHt$pH@A_A^_Hx"HH@SH HH	_"H#H [3H9HH!H3H9@SH HH	"H#H [H\$Hl$Ht$WH @#3HHtLHH;t=Hx0HOE3IJHOH7G

G
g
@wH@HGH;uH3!H\$0HHt$@Hl$8H _HtJH\$Ht$WH HHHH;tHa%H@H;uHLcewA;0tqt~!3HM}}}1RHMP,HMoHc}+AQDCAADAAAADɋD+ʙHcHAHcHimHcHHHcEHRHIHkH\$`Hl$hHt$pH|$xHPA^HHXHhHpHx AVHPALHC@|3tHt	H@t
@uJ؃@tdH|$(LL$0L6|$ 3Lt$03H\$8t$@|$DHHtE3Hu|$DHt	H'Au3@HDMH>H\$`Hl$hHt$pH|$xHPA^E	MHH	c=E	MHH	=E	MHH	;=E	MHH	=E	MHH	=E	MHH	=@SH DIHLHQ3uN߃@t^H|$(LL$0L|$ 3Lt$03H\$8t$@|$DHHtME3HH˅t
/|$D?u3>HDMH;H\$`H|$xHl$hHt$pHPA^HHXHhHpHx AVHPALH?@d3tHt	H@t
p=u2߃@t^H|$(LL$0L|$ 3Lt$03H\$8t$@|$DHHtME3HvH˅t/|$Dt>u3=HDMH;H\$`H|$xHl$hHt$pHPA^H;s3H;H;s3H;H\$HT$UVWATAUAVAWHH`3HHu_WH:H99EH}tWHHUPfEP*?@}R^HHuLME33LEHDu	HH9;LeHuHuLLeHIH}PH+LLIIHHHI;HGIHt%LIHA8<uIHLIL;uLMPAIIΟHHtwJLHUHHUXI;tVHH+HMMMIC8<(uH+IHUPMHEHEXHMHUJ9IIHEXM;uHEHDH3ILH+HHI;HGHtIHMH;uHAH$H`A_A^A]A\_^]E3H|$ E333LH\$UVWATAUAVAWHHHӼH3HE3HUHHu_WH:H99EH}tXHHUE*?f}HHuLME33LEHeDu	HH9;LeHuHuLLeHIH}H+LLIIHHHI;HGIHt&LIHfA9L҃	uA7AIEA>A3AHAAH̋A3E3HAE3H3H\$WH@HHL$ bHD$0Ht xuAE3H=3ɀ|$8tHD$ H\$PH@_̋A3E3HAE3H̋A3E3HAE3H̋A3E3HAE3H̋A3AW{HAAWH_A3EAIHAHEA1̋A3E3HAE3HHH@SH HH	Ht
H#H [3H9@SH HH	Ht
H#H [H(H(3HHf9AuHAHf9uHAH33H9HHXHhHpHx AVH@=E3HHHfD90tHHfD94FuH4FHfD96uLt$8H+Lt$0HHLDDt$(3Lt$ 3HctLHHHt/Lt$8DLt$0LÉl$(33HD$ tHIIHfIHt	HoH\$PHHt$`Hl$XH|$hH@A^H\$Hl$Ht$WH >3HHt[HHf94HuHHHf90uH+HHH,HHHtLHHlH3HH\$0HHt$@Hl$8H _HHHHHHH@SH HH	cH#H [@SH HH	GH#H [HH!HH!@SH HH	H#H [@SH HH	H#H [H({DHT$0HHL$0HFHD$0@H(H(KDHT$0HHL$0HEHD$0@H(H(DHT$0HHL$0HEHD$0H(H(H(CHT$0HHL$0HrEHD$0@H(HH@LI[IkIs WATAUAVAWHH~H3H$L83IKHI[DDDMLaH\$XsA9$u3Ld$ AIKߡHb3HD$X~E3LcH֋13LOH֋3H;Hֹ3L$H9\$XMM
MHI͋ÈH=|A$H$$$IH8MM\$@D$PA$D$8D$0HL$(3ɉD$ D@/hqA$HH8MM\$@AD$8D$0HL$(3ɉD$ g,9t$P~58$t,H$8t Q
HcB( ;~H8YuA$I\$0AD$(MHL$`HL$ 3Dd$PIfA^]AHD$hD;~?8$t6H$8t*QHcAfEG;~H8YuIIAAOA I0AG AO0A@IPAG@AOPA`AG`LApHAG	HApAAI AGA0AO I@AG0APAO@I`AGPAO`IGpAxAGxA|fAG|AxAAAA ANA0AF A@AN0APAF@A`ANPApAF`ANpAFxA|fAF|A~AF~xE M0E @M0PE@`MPpE`MpEx|fE|~E~HHtN;uCHHnHAI+YHI+JH>HD$X0HHD$`HHD$hHIHHHDg$HL$XIIHIMHHtHxUHHHWHHHMYH3qH$H31L$I[8Ik@IsHIA_A^A]A\_HDHH@SH HH	+H#H [HH!@SH HH	H#H [HSH HHIH;
tHK H;
tHK(H;
tHK0H;
tHK8H;
tHK@H;
ztHKHH;
ptmHKhH;
~t[HKpH;
ttIHKxH;
jt7HH;
]t"HH;
Pt
HH;
CtH [H\$Ht$H|$UATAUAVAWHH@3HMHDH]H9@uH9HuDL5YtAAe3LMuAI͋?3L]Mu
IPH9@RHI3L,Mu
IIH@IFLHD$ AHMA5IN AHL$ LHMAՋIN(AHL$ LHMAHMIF0ALHD$ AՙAMn8LLl$ HMAQ贙APHMLIF@HD$ AQ蓙AQHMLIFHHD$ AQrHMIFPALHD$ 3SHMIFQALHD$ 34HMIFRATLHD$ 3IFSAULHD$ 3HMHMIFTAVLHD$ 3טHMIFUAWLHD$ 3踘HMIFVARLHD$ 3虘HMIFWASLHD$ 3zAHMLIFhHD$ AQYAHMLIFpHD$ AQ8AHMLIFxHD$ AQAHMLIHD$ AQAPHMLIHD$ AQϗIAQHD$ LHMAQ諗t*IcIWIOIGgIU38
A<	w0
AI8u;uLIHALuAHAHAN@ AF H0AN0@@AF@HPANP@`AF`@pADAHDIDAHHIHHHINHHHINHHHXINXHHH`IN`E,$MtE/HHtHHt$uHHL3LLL\$@I[0Is8I{@IA_A^A]A\]E3HD8	t
A<	w0
HD8
uÀ;uLIHALuHtfSH HH	H;
t^HKH;
tLHKH;
t:HKXH;
;t(HK`H;
1tH [HHXHhHpWATAUAVAWH@3HHHHXH9HuH9@uDL5DLHuSHzAHAN@ AF H0AN0@@AF@HPANP@`AF`@pADAHDIDs3L)Mu
ImA$H9HH>3LMAHL$0HHALLt$ INAHL$ LHL$0ՋMnALLl$ HL$0ǓAHL$0LIFXHD$ AQ襓AHL$0LIF`HD$ AQ胓tII,IIU3
A<	w0
H8uS;uLIHALuHLIHIFHIFH͘IFXHʘIF`A,$MtA/HHtHHt$uHsHgL3LLL\$@I[0Ik8Is@IA_A^A]A\_E3HD8	t
A<	w0
HD8
uÀ;uLIHALuHv̺j̺^̺R̺F̺:HH@SH HH	H#H [3H9HH!H\$Ht$WH 3HHHH+HHH;HGHtH2HH[H;uH\$0Ht$8H _HH\$WH HPHu	HA;HHtHH6u H3HHH\$0H _ǃ\H3H\$Ht$H|$ UATAUAVAWHH@LPLE3HUILe0IEl$1AHE0AMи%I$E+Mºk+ȋIHMHD$ KEMIG8MHHMHD$ 'HMI`EHMƺHD$ EMIMHHMHD$ ڏAHm0EA8IEeHGMEMHD$ HM蛏EH|$ MHM耏EMHMHD$ HM[HMH`EMHD$ <HAIpI0Mƍ{&HD$ DύSHM_I8DEl$HD$ MHMADHM{IMHD$ 辎HMIDMHD$ 蟎DcI@EMHD$ AHM{{IHDMHD$ AHMXHMIPDHD$ MA3DKIXM3HD$ HMEHMEeIAMHD$ IDHD$ MHMAύIDHL$ MHMA词L\$@I[8Is@I{HIA_A^A]A\]3H9@SH HH	/H#H [HH\$Hl$VH HًHK8uHKpxHjH0U[H@HHHPH`)HH
H0HUHPHDH8H,H\$0Hl$8H ^H\$WH HPHu	H<RHHu3HH>uHH&3ǃ\H 3H H\$0H _E3LfD9Ht)MfE9tAf9tIAfuHfD9H+HMu3ftf;uHHIu
+@UATAUAVAWH`Hl$0H]`HuhH}pHzH3HE DEHMHMFuHEpEMċ҃d$(Hd$ Lcu3IHHOH;HHtuHOH;HH#H=HGw:H;HH#HAH;w
HHH+H\$0HtyH;HH#_HHtH3HtHL3H[EDt$(MH\$ .tLDHA3HtHK9u}tHEHM H3IH]`HuhH}pHe0A_A^A]A\]AHHtHHtHHtHHtHA8AHÈH9PtHHtHxtHPHtH IuH yH\$Hl$Ht$WH HHHtyH
fH;tmHHta8u\HHt9uH~HHt9udHHLH@HHtG8uBHHHH+HH+HH H(H{8HvH9GtHHt9u
HHtHOHt
9uHH HuHH\$0Hl$8Ht$@H _fHtH<8H;t\øHt0SH H8HH;t\u
HH [HtH7H;t\øH(HADIHHtDHHtDHHtDHHtDHA8AH!H9PtHHtD
Hxt
HPHtD
H IuH 5H(H\$WH 'H
xtHHu6HHө&HعHuSHH\$0H _H\$WH HHtIHtDHH;uH9HH-Ht"H{uHH;tHH3H\$0H _H\$WHH̀H3H$IHHL$0U~2IHD$03IfB9H\$Ht$WH0HzH3H$ H AxLD$0HKHҁ3usFIHHT$0u-IIfB94OuIHXLǺUu4KCЃH$ H3hL$0I[Is I_E3Ht$ E333SH\$Ht$WH 3HHHtVf91tQHlSStAHdSH@u$HX DNLD$0t0D$0+HcLIK&蘡u
IL$II
y}u;~Hl$HHt$PH\$@H|$XH A_A^A\HHXHhHpHx ATAVAWH0IHLE3HIDcLXL3H{fE'HfD9 tLAT$H
rEHHfD9 tMHfD9 tD9cuALH
A@tHHfD9 tD9cIH؅|HtHH IfD&IfG9$OuIMǺUH$DH@LźHt{HA@LǺHtZ_H観HuP.H薳HtA@LHAQ|tA
HEA3H\$PHl$XHt$`H|$hH0A_A^A\E3Ld$ E333H\$Hl$Ht$ WH HuH3H$HHHHLD$ Axȋҁ3ۅuCCHHT$ 蟞u$H
Nf;1tHHcH
rwwЃH$H3L$ I[Ik Is(I_H\$WH HHL3HHf9HHH`uu!ODNLD$0 1t-D$09HO/OLD$0A u3D$0uH\$8Ht$@H _E3L
HAAfA;tDIIcH
r3H\$Ht$WH 8LD$0A
 HwE3҅u3S;\$0tHtDLEAIIBfv
fafwAHHHfE9AuD;tH\$8Ht$@H _HHXHhHpHx AVH 3MHx0I+HcHHHTזt+y_w;~2H\$0Hl$8Ht$@H|$HH A^HHHHI@USVWATAVAWHH@HlH3HEILLH3HEEHME3HHILHHtfD9 t<H
:LDeHHtyfD9 tsHHtfD9 tHM	HMD9e=:LH
6HHtfD9 tHMwHMlHHtQfD9 tKHHHHfD9$HuHAH
7EuDeEEED9eIIHUHH#Q؅MMtAMHE3AqUDHtdMH E3DM@DLǺIt9MLDκ-tHDNDF3HMH3{H@A_A^A\_^[]H(HT$0HHL$0H
HD$0HH(H\$Hl$Ht$WH IHHHt3HBHI;sK3AHt
pH3HHHHHtH;sH+H8L3裓HH\$0Hl$8Ht$@H _H9H(&HH$H(H%H	H\$Hl$Ht$WH HHH;u\HH+HtHՄt	HH;uH;tH;t-HH{tH3Ht
H3HHCH;u2H\$0Hl$8Ht$@H _H\$Ht$WH HH;t&HZH;Ht
HX3HHCH;uH\$0Ht$8H _Hh@ƒ?+3HH3HihHыH3ƒ?HLQhHAй@?+HI3H1h@ƒ?+3HH3HE3HALL+IIH;MGMtIHHIM;uHH
uH\$WH H.HHtHYHӅt3H\$0H _@SH 3Hg˃?H3H3HH [H\$WH H3lHDgƒ?HH3ՐH˹@+HH3H=3HH\$0H _Hf@ƒ?+3HH3H\$LL$ WH I
Hf˃?H3{Hˋ%HH\$0H _HH(HLHH LHP HHH(HqfHыH3ƒ?HLYfHAй@?+HI3̋HËHË	I̋	HfH3Џ?HH\$WH ٹHeƒ?ȅHuLH3~LxH3qHHr@+3HH3IHu3Ht
HӸH\$0H _̃t/t	ttt3HHHHՎE3HALL+IIH;MGMtIHHIM;uHHH	9JtHH;u3HH(w

 rHH(HLH(MKMCD$8ISD$@IKH(H
H
H
H
H(O
HH(H(;
HH(HSVWATAUAWHHE3D!h@@$t"tttqAviDk
LHu"HHHH	9ytHH;u33HuǶ耼HY@2@$?t3t	t tt3"HHHHڌH$@t2@tHcʃ?H3HLL;I$Mu@t	AO=VA	w@As:IEH$HD$0IeuV@$D$ @u2Hh
HIEH
a
HHHD$(H;t1H`HH6bƒ?@+3HH3HA	@t
|$t3auHIHҋSAIHuЋA׃wAsH$IEu$HHHA_A]A\_^[H\$H|$Lt$AWH0LHBHD`2E3AO[tu:=ъu1H
t	#HHt3L`AЃ?ML38IL|$ It@+IM3L0!t
 I	HHtL=L98u&H
LHHtL8IHUHHLMJH;t9xtHH;u3HZHPLItNI;t9zuL2HHJI;uIw

 rHH\$@H|$HLt$PH0A_@SH I3LL8L$Pt-LRM3A	vW0AHI…tH;rH;rAx"0 AIAA
AIAIM;r3H [H\$WH 3ILLҋ@8|$PtO-f
LROM3A	vfWf0fAHItH;rH;rfA;ر"萷'fA:IAA
fAIfAIM;r3H\$0H _@SH HI3LL8L$Pt-LRHME3I	vW0AHIHtH;rH;rA2" AIAA
AIAIM;r3H [H\$WH 3HILLҋ@8|$PtO-Hf
LROME3I	vfWf0fAHIHtH;rH;rfA;莰"F'fA:IAA
fAIfAIM;r3H\$0H _@SH0EDHu6H0[MtDL$`AHHHL;w"AB";wDL$`AEH0[@SH03EDHu輯tH0[MtDL$`fAHHHL;w胯"AB";wDL$`AEH0[@SH0ELHuBH0[MtDL$`AHHHL;w	"AB";wDL$`IEH0[L@SH03ELHuȮ耴H0[MtDL$`fAHHHL;w菮"AB";wDL$`IEH0[j@SH03HA
uHyEȈD$ IHH0[H83A
uHyD$ H8@SH03HA
uHyEȈD$ IHH0[H83A
uHyD$ H8@SH03HA
uyEȈD$ IHH0[H83A
uyD$ H8@SH03HA
uyEȈD$ IHH0[H83A
uyD$ EH8@SH03HA
uyEȈD$ IHH0[H83A
uyD$ }H8@SH03HA
uyEȈD$ I]HH0[H83A
uyD$ H8@SH0ED$ IHHH0[H8D$ H8@SH0ED$ IH&HH0[H8D$ *H8@SH0ED$ IHHH0[H8D$ H8@SH0ED$ IHrHH0[H8D$ H8HHXHpHxLp AWH0IHLH3ۋMuTuIHtHHtH+LHtNHH88uHH'IHuMHHuHtH>H\$ E3E333ðH\$@Ht$HH|$PLt$XH0A_HHXHpHxLp AWH0IHLD3ۋMuPvIHtHHtHLHtOHHf9xuHǺH"IHuMHHuHtH>H\$ E3E333辯H\$@Ht$HH|$PLt$XH0A_H\$Ht$H|$AVH0HLHu)gH\$@Ht$HH|$PH0A^H!HtH"MtI-HHu3HHÀ<uHH$IHuLHHu
HtHHd$ E3E333ˮHHXHhHpHx AVH03HLHu.艨AH\$@Hl$HHt$PH|$XH0A^H)HtH*MtIHHu3HHf9,XuHúHCIHuLHHu
HtHE3Hl$ E333@SH H3Hu躧s3<3H=tӹhHHعHH [@SH H3HuN3<3H=tӹHHع:HH [H\$Ht$WH H@HHtWHtRHHǀ<>uH8t?HHH<uH;v<9=uLHt
HH;HHH3H\$0Ht$8H _H\$Hl$Ht$WH Hl@3HHtXHtSHHf9,~uH9(tAHHHf9,AuH;vfHFE3I֋YHP3H\$@Hl$HHt$PH A_A^_賛8uɛ
辛Hˋ8yE3HӋHLzHuz
OHHT$L$USHHHLcAu 	xtD;$nskIL
j?IHHID8tHHy՚ AHEDE0HELM0HE DELEHEHUHM(蒚 誚	bHH[]H\$Ht$L$WATAUAVAWH EDHcكuF ^	xt;ImslHLIL-6i?HKDL08tEuKDD08u	ڙ EAԋ0v趙 Ι	臟H\$XHt$`H A_A^A]A\_H\$Ht$L$WATAUAVAWH ELHcكuZ r	xw;]lsoHLIL-Jh?HKDL08tHtHKDD08u	 EIԋHuHǘ ߘ	蘞HH\$XHt$`H A_A^A]A\_H\$Ht$WH HcAˋVwHu菘	7DNjHЃtHLfg?HHHId8H\$0Ht$8H _H\$Ht$WH HcAHvHu	HSDLD$HHH"u8qHD$HHtHLf?HHHIȀd8H\$0Ht$8H _LI[IsWH0d$X3AHcD$\MCIS HDHuSd$XLD$X3HDωD$\HetH|$X~!HT$ E3E3HB
묋D$XH\$@Ht$HH0_H(ELD$Hu$]HHD$HH(#cH(d$0HT$0D$0H(H(Huj#luى
l3H(H(u
*	Bx.;
is&HcHeH?HHHD8@	褛3H(H(bMLE3ɅuyMtlHu貕kH(HtL+AAfwf DA@fwfA HItftfA;tADD+AH(H(HHXHhHpHx AVH@E3IHHAMHu躚HtIHL$ HD$(L98u:H+>Cfwf Afwf HHtDft?f;t8HT$(=BHT$(-BHvHHt
ftf;t+D8t$8tHL$ H\$PHl$XHt$`H|$hH@A^DE3ACAʙL+HcHB+tyDHD@E;~̓HHXHhHpHx AV3L54DHACHU+LcIHN1I+BJfwf A	Afwf IHt
ftf;t+tyEXEPE;~IHADH\$Hl$Ht$ H|$(A^E3LLMtDL+CAfwf ABfwf IIt
ftf;tDD+AH\$Hl$Ht$WH0IcDHuu
Huy3yE3H-AC
+AHcH+)tyDPDHE;~ՃxHUHHlHH~;}HLHuGH\$@Hl$HHt$PH0_Hd$ E3E333H(Ht"xHH=sHH
63H(H\$LL$ WH II؋
TmHHcHHHLt`?HID8t$pH|3ۅu)H9	mH\$0H _HH(HLHH LHP HHSH(̋HHH̋HË	m@SH HL_HcHHH?HID8t&\oHt3jHяz	H [̋	)l̉L$H8Hcуu
K	lxX;9csPHL-_?HHHID8t-HD$@T$PT$XLL$PHT$XHD$ LD$ HL$HA	蛕H8H(\LLE3ɅutHu諏dH(HtIwL+CBfwf A
Afwf IIt
ftf;t+H(H(HHXHhHpHx AVHP3IHLMu3Hu跔HtL;vՎ莔IHL$0HD$8H0HuCL+A>Afwf Bfwf HHt
ftf;t+-t$(DMH|$ Nu
BX@8l$HtHD$0H\$`Hl$hHt$pH|$xHPA^̋
[jVE3HHXHhHpWH`HHIHHIHu3HtHu訍aH;v臍@cHD$HH0HuLL$HLHHV;@HL$HD$8L͉|$0AHt$(|$ Qu
"X|$XtHD$@L\$`I[IkIs I_@SH ;3҅uf_uH [@SH :3҅uf_uH [@SH@HL$ fHD$(HQ%|$8tHL$ H@[̺:̺:f	u@ú@j:̺ ^:@SH I:3҅uf_uH [@SH :3҅uf_uH [ú9̺9̺9̺W9̺9̺9̺9̺9@SH@3HL$ 0HD$(HQ%|$8tHL$ H@[̺V9̺J93f;f	u@ú@"9̺ 9̺
9̺8̺8̺W8̺8̺8̺8̺83H9@UATAUAVAWH`Hl$PH]@HuHH}PH6H3HEHc]`MHUEH~HI_O;ÍX|DuxEuHDpDMA҃d$(Hd$ gLc{IIHHJH;HHtrHJH;HH#H=HBw7H;HH#HAH;wIHFsH+Ht$PHH;HH#˅HHtH3HDd$(DMHt$ AHd$@EHd$8LHd$0AL}d$(IHd$ HcbAEtREpN;DHd$@EHd$8LHd$0AՉD$(IHEhHD$ 觮HHHJH;HHtvHJH;HH#I;HBw>H;HH#HAH;w
HHqH+H\$PHH;HH#uHHtH3HtsHd$@EHd$8LHd$0AՉ|$(IH\$ ڭt2Hd$83H!T$0DϋEpLA΅uf!T$(H!T$ 
u`HK9u觃3HtHN9u菃HMH3EEH]@HuHH}PHeA_A^A]A\]ÉD$(HEhHD$ HK9uGH\$Ht$WHpHIHAHL$P$HL$XD$@Lˋ$DljD$8H֋$D$0H$HD$($D$ 3|$htHL$PL\$pI[IsI_@SH 3Hu^HtEAOHH;w-"MtIQHA0DEtHA0DHAEx:5|0HȀ89t91uAAIIB8\uIHQp3H [@USVWATAUAVAWH$HHHM2H3HH AHD$XLD$PT$8D$HHT$HLLL$@I4AMHHHH#HH#HE#AAKK,ȉ|$dEVrEH D#|$hDd$ A։T$`3Džp;UE3BDdB9?ED;ud$(D[EA AAAIA+HA+DAt3D+AAE;AA;AA;u
EtA2AEArA;DBE;tWEE+C<A;rHD;sFTdE3A@;sTd3A#ԋED#AAACTdA;tT$`3EtddA;uEAFDEE3Dž4ADd$ D0DDt$`hd$(D[EˍBAAA IEE+AHA+ދDdDAt3D+B
E;AA;AA;u
EtA2AEArA;DBE;t\EE+C<A;rMD;sFTdE3A@;sTd3A#D#AAAAAE‰TdCA;tT$`3EtddA;uEAFDEE3403Džp;
E3BDdB9ED;ud$(t3A D+D;AA;s	DDdE3A;sTd3A3ЋA͉TdA;tT$`AHE3AD+Dt$`HLWD@θEIDD0M7H4L;Hk
d$(BDdt3A D+E;AA;A;u
EtA2Aubu^ArA;DBE;t?A;s	DDdE3A;sTd3C3ЋA͉TdA;tT$`EAFDEE3Dt$`+H3HLVD~@ϸL3V"詅D0EAHD$4DD$$&ED;DGDl$0AE""#"ً3HLÍHVH
H "HHLHHjDAuE3D0EE3LE3B4AIHLB4I AE;uEt40ss0D4D0AE3D02D0A4MIED0Mt@H4L;wHiL3T-~"D0EE3LE3B4AIHLB4I AE;uE;H4ELH4LDEEEEHHDE3E3HT$(DECtA…u!E;B!EzD3EEAAstfE;uAOCȉA9EAHHBHA9HBDH A;tHT$(딅tNAslE;uAAAAAӋHЉDH څuAsHT$(AE;EID0Mt@H4L;wHgL3R|"ׁD0Dd$$Dl$0E+HDd$$5D$4|$ +A"t{EE3DE3B4AIHLB4I AE;uEtA0ss)0D4D0AE3D0E3D0D0{AL$0HԧD$(DD$$&ED;DGDl$4AE""#"ً3HLÍHTQH
mH "HHLHHdeDAu
E3Dt$`EE3LE3BLdAIHLBLdI AE;uEt)|$`ssD$`DDdDt$`AE3Dt$`2sDt$`gA\$dMIED\$`Mt<HL$dL;wHdL3=Py"QDt$`EE3LE3BLdAIHLBLdI AE;uE;HL$dELHT$dLDEEEEHHDE3E3HT$HDECtA…u!E;B!ErD3EEAAstfE;uAOCȉA9EAHHBHA9HBDH A;tHT$H딅tNAsZE;uAAAAAӋHЉDH څuAsHT$HAE;EIDt$`Mt<HL$dL;wHbL3>Nw"R}Dt$`Dd$$Dl$4E+H+Dd$$bL$0D$(+A"tbEt~E3DE3BLdAIHLBLdI AE;uEtH|$`s|$ s.D$`DDdDt$`ADt$`.Ht$@d$`Hދ|$ Ht$@d$`H}Dt$`|$ Ht$@HEtgE3E3BDdHALHFDdAI E;uEt;|$`ssD$`DDdD$`%Ld$`HL$dE3ɺH0HL$`{
1H^EE3E3B4HALHF4AI E;uEtZ0ss0D40;L0H4E3ɺ'u0H^HD$PL$88x
wHD$XHȋH;HBHH;A	DT$`EE3E3BDdHiʚ;AHLBLdI AE;uEt;|$`ssD$`DDdD$`%Ld$`HL$dE3ɺ\H0HL$`WzDLD+AAD*AH0DE;rADD;uHH+I;IOHH;HH3K2HĸA_A^A]A\_^[]@SH H9<uCH9CHH [H(ytq9H(DLLD;t23Et#HBL
B9LuA;uDE3LLD;t2AEtHBLB9L
uA;u39H\$Ht$H|$AVH LH3HLI@H|$@BD3FH\$0Ht$8AIH A^@USVWATAUAVAWH$(HHuH3HHL$8MHL$`LL$PMLD$p7D$`E3<uDl$hHL$`78D$hH\$8HHMwH# HIHɃ
AHu,Iu'H@L+IEoCo HL$88tAG_7HAH#H\$8D$8D$XHT$XL‰t$LI4MHMI#IL#LE#A*8a7,DuAEI D#DuADd$0A҉U3Dž($p ;aEAȋD9$JED;uD[Dl$8EˋAAA+IڋHA+ADAtA+AAD;AǃsAsuAEuAAEArA;DBE;t\EE+C<A;rGD;sFTE3A@;sT3A#ԋED#AAACTA;tUAE3AEtADlA;uEAFDEDu
E3EDmDžTDd$0ADPD D(td$8D[EˍBAADIE+AHA+ڋDDAt3+B
D;AăsAsu
EtA2AEArA;DBE;t\EE+C<A;rMD;sFTE3A@;sT3D#AAA#ADDTAECA;tUE3AEtDlA;uEAFDEDu
E3EDmT,3Dž($p ;	EAȋD9$ED;uADl$8tA+;AA;s	DDE3A;sT3A3ЋA͉TA;tUAH$E3AD+DuHL DD@EǸI$E3DPD M=HTL;H$XBDl$8DtA+A;AssuAEuAAuhudArA;DBE;t>A;s	DDE3A;sT3C3ЋA͉TA;tUE3AFEDEDu
E3EDmAH$+3ҋHLBD~@EǸ$IL3Bl"qDPEAHD$HDD$@&ED;DGDl$DAE""#"ً3HLÍH$ 0BH
IH "HH$LHH@VD A$uE3DP	EE3LE3BTAIHLBTI AE;uEt4PssPDTDPAE3DP2DPATMIEDPMt@HTL;wH$JUL3@Yj"pDP	EE3LE3BTAIHLBTI AE;uE;HTEL$HTLDEEEEH$HDE3E3HT$8DECtA…u!E;B!EzD3EEAAstgE;uAAJBȉBEAHHBHBHBDH A;tHT$8듅tNAs~E;uAAAAAӋHЉDH څuAs0HT$8AE;EIDPMt@HTL;wH:SL3>Ih"nDPDd$@Dl$DE+HٔDd$@4D$HE3|$0+A"EEEDAAATIHLTI E;uEtNPss6PDTDPADPE3EDPEDPuDPiAL$DHD$8DD$@&ED;DGDl$HAE""#"ً3HLÍH$ j=H
H "HH$LHHzQ $uE3DuEE3LE3BLAIHLBLI AE;uEt%}ssEDDDuAE3Du2hDu]A]LID}Mt:HML;wH$PL3_HHL$@VE3HL$@E33fVuVW\;G蜤HHuKW`W3ۅ$DHL$@HHuH3踅HHH\$0Hl$8Ht$HH _H\$ UVWH0HH3HD$(3AHEyV\3t!ruVV
%؅tf@D$":.f\$ f|$&D$ .Ht~Df>HHL$ sE3HL$ E33UuUU\;GMHHuUV3茄$DHL$ HHuH3iHHHL$(H3H\$hH0_^]H\$Hl$Ht$WH E33E3HaT3uTU3X;غG蓢HHuBUWUDHHHt	HHHH賃HH\$0Hl$8Ht$@H _H\$Hl$Ht$WH E33E3HS3u+TdT3X;غGHHuTTDHHHt	HHHHHH\$0Hl$8Ht$@H _H\$WH AHEuFTY35LE3ɋR;r
 T"݅u^SSHH\$0H _H\$WH AHEuSY35LE3ɋR;r
S"݅uR+SHH\$0H _ALLIE3H%8RALLIE3H%(R@SH0HH3HD$(vS.S
X343ۅuC)f@D$":\fL$ HL$ f\$&SËHL$(H3H0[H8d$(DHd$ H3A^H8H8d$(AHd$ >H8H8d$(DHd$ H3AZH8H8d$(AHd$ :H8fL$UHHPf;HMHEL8MuUBfwif cMf;s)-uUAHEUH,AHE DL$(LEIHD$ 
$UtU }tHMHP]35HXH1H3HD$@3LH LswD HH |HL IL AuAAɃHT uIEEu3HL$@H3HXIE3H\$WH@HHHuPsV3bHtH;sIHL$ xHL$0yuH%HSHH;w
DuHH+ʃH+Hˀ|$8tHL$ HH\$PH@_H('T3ɄH(@UAVAWHpHl$@H]PHuXH}`LehHH3HE LMHAHMƼHEE3E3ID`qHcu3HHHJH;HHtyHJH;HH#H=HBw>H;HH#HAH;w
HH99H+H\$@HH;HH#KHHtH3HtODLËIKqt;DEpAAHHd$8Hd$0I#DD$(AHT$ L3dO3HtHK9uJ}tHEHM H3H]PHuXH}`LehHe0A_A^]@SUVWATAVAWHH+H3H$H$03AMLH>LL$@D$ DIHc؅tCWH+L3HIJH9>HCLcLD$@HZ3)MzE3ɉ|$ DIILcIϺKHHt%LD|$ DIIatHHHHIt;u;E3E3IoLctQIϋQKHHtELIYo랅u)|$0LD$0DI9otD$0H$H3
HA_A^A\_^][E3H|$ E333RD
3DE+uH+fEtHD
DE+tEyH(HuvL/RHH(L3H
"H(H%KH(Hu:LQHH(L3H
r"H(H%KHHXHpHxLp AWH MAHHٹ轊KD8DHH3tIK0!HuHtHxHHIKD8車H\$0Ht$8H|$@Lt$HH A_HHXHpHxLp AWH MAHHٹ3KD8DHH3tIK0!HudHtHxPHIJD8H\$0Ht$8H|$@Lt$HH A_HHXHhHpHx AWH0HAAHHH8Au	TH
HIXt3H膪tHt;t!HH<uH;rHt"dLHHVGum3NiHt?HxHHt6HHuQIG3HFHHtLIGt6H\$@Hl$HHt$PH|$XH0A_Hd$ E3E333OHd$ E3E333OH\$Hl$Ht$WATAUAVAWH0IcL% E3HHAAM94uAA@G3I]EIHfD93uAIHt3HXtHt=t#HHfD94CuH;rHtfD6"dLHHv|uo3NHt?HxPHt6HHuIIF3HDHHtLI+|t7H\$`Hl$hHt$pH0A_A^A]A\_E3Lt$ E3333NE3Lt$ E333NH\$Ht$WH0HHٺ.HHuM2H\$@Ht$HH0_H;rH+H;v3HqHDB$kHtH+A$HHL=uHd$ E3E333MH\$Ht$WH0HHٺ.e6LHuM2H\$@Ht$HH0_H;rH+HH;vIp3HDB$kHtLA$L+HIHI+LΚuHd$ E3E333LH	H	H%DH\$WH HcH=4H<uD3HBHH\$0H _H\$WH HcH=H<uVD3HsBHH\$0H _H\$Ht$WH0bHHt~HйHwcHޅtt
uutsHH+EA$LH_u1HH<uf.0D2H\$@Ht$HH0_Hd$ E3E333yKHHXHhHpHx AVH0HcHE3L94uAVL;HH#HAH;w
HH%H+H\$PHL;HH#8HHtH3HtTD|$(DMH\$ A]9t2Hd$@EHd$8LHd$0UHMD|$(H\$ 'Y3HtHK9u	73HtHO9u7HM(H3WHe8A_A^A]A\_^[]H\$Ht$WH`HIHAHL$@$HL$HD$8Lˋ$DljD$0HH$HD$($D$ |$XtHL$@H\$pHt$xH`_38tH;t	H<u@SH HC3H [@SH d$0Hً	d$4KHL$0D$09u
D$49Cu3H [@SH d$8Hكd$<HL$8wt"HD$8HL$8L$8Huu3H [E3D$HT$HHH#H@CH;AH;rHH;v~HH?H;s+HtbMtHHD$D$FiH= t&H=@tH;u0HE'HE HEHE HEHE HE HE	0HEHu8H }@t3HE!P HE0HEHHEH`HE!P`HEHPHHMAA A#A HE0HHEHHHEH`HUB`A#B`HEHHPP3LMDBHMAtH3AtH3	AtH3
AtH3AtH3t0ttu(H`H3
H+H3H+
H#}@tAPHAPHH\$8Ht$@H|$HH ]HHHD$xD$0HD$(HD$pHD$ HHH(tAw&"!H(\$ T$SHPL
IE39tAH
~HH;|3IcHIDH$HD$(Ht\D$pD$0D$tD$4D$xD$8D$|D$<$D$@$D$D\$ XHL$ uD$@6$HP[@SH =؃?MH [H\$Ht$ WH HHD$8с##ωL$0=t%@t L$0t$8H\$@Ht$HH _@SH H?ËH [H(?H(D$HL$H0ff#D$ HD$ fD$H0f#fffL$D$(D$WLf.z	u3HD$LI0fDT$H uE3ɹf/AAu$D$D$yD$D$tT$D$f#fD$Et
ffD$D$D$HD$H0f#D$?ffD$D$JL$L$HD$H0f#º?ffD$D$D$ff#ȁA
ùD$HD$H0ff#f+D$HD$H0D$f#fffD$D$D$HD$H0f#D$ffffD$D$D$HD$HH u
uÁu
uAHH0fA#fA;uAfA;uut3%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%D%6%(%%%^%P%B%4%&%%
%%%%%%%%%%~%p%b%T%F%8%*%%%`%%dLcAF@UH H} u"HcMHHHH?HH€d8MH|H ]@UH HHEHH ]E@UH HH ]E@UH HH ]E@UH H3H ]E@UH H3H ]E@UH HHEHH ]kE@UH HH ]RE@UH Hꀽt5EH ]@UH HH ]E@UH0HH0]D@UH0HH0]D@UH HH ]D@UH HH ]D@UH0HH0]D@UH0HH0]D@UH HHM@fH ]@UH HH ]LD@UH HHEHH ]@UH HMPH ]@UH HMPH ]|@UH HHEHH ]b@UH HHEHH ]C@UH HH ]C@UH HH ]C@UH HH ]C@UH0HHM0yu	HM0eH0]@UH HH8t8t3H ]@UH HH8t8t3H ]@UH HH3Ɂ8H ]ooppooooorj`j`oNo>o2o&ooopokll$l8lNl^lrlllllllllmm&m>mw0kkvvvvvrvXv>v2v&vvvuuuuuuuluXuDu,uukkkkxklk\kvDkkkjjjjjjjvtwttttpppppqq8qRqhq~qqqqqqqr*rBrZrrrrrrrrrrss&s6sDsTsvssssssssstt&t8tHtZtjttt0pmtmhmnnnnnnnnrndnVnDn2n nnmmmmmmmm\pnpLp@@ܕ@@̕@2@@@@}@4@@3@+dWnOA	AlGRWpO6a'wj5ObFÅm]rLwx,aOMG	 ķ]v+qAOpO]և+DW^
Oor;owLf[MEĀv*cMjVDEs"@0(9A8L7ʸ!A9mG-*+$%|QOz)(BF\GaUFEzfCNItwׄtxMNI{@>K]TKFad4Cz"zOy|I)sO>BqB
7EC)t0ō*M^2mFT
 }jL^6CTv]=D%OcgP0V	AH
FFPB,ɨ=$HܨEye64BlOUᏢWU]O	ɊFiyŜ?Oɝa3K@~OqK
M;rG¸E\\GNˇbo-XCMtY&h~vIsB U[6J[CS[bHNAF"JL
G:7՝5F3+zFO${aύtA^?UX&I}!<OGFV;&OF}P($IZ^9&M[OrWG 35w~s5i+.bi;'~.gC\[bGEրEv+0PoSi)!@'QL.JifrtgHU;aއ-+o.Eцf@"nO :i+00.PRO—-2NfHyu	M7?eEd9Ē^F{w@=TR%9O'HKlqt}
{ҜJ3F̉.|-!CQ7o֩Cmy4[_eOkmM]`g.H	iVFO#A,\V׉#G``
E%6QM\vWNVM.^R
FHsp^QmOpNr-O&oORO%e{HqC,㟽$\E9Ot<&KA>=a-kQG^),=Nk.4qa޼^Ol^\`U;MW.I|Kg+*U6F:(Y;J\FЗ4mc/4*&{-@`ެ)F#Ϋ>/ICVJNztI6FOEг@wiKw^Ҩ\I;%Sjc(=O'>OСFVe\Kz~|Tn9{ŞC
$&;ل.CZ0YctXT9bq^F*O  !:i+00iI~+.ͩ_@^A% xSiMEQ 3߷;`[}N8úGˢ)w]+.DJQ3(9O>ܥ>G2A`tpZdfapHUeі[/tAxC(DW@Xzvi>VMYFDAtKpȞ&Aõ*.7V`Ɔ'":i+00hXt_vJ)v؂تI'9Y:Oh7
e.{ JOe/+dWnOF]K$Lb`wG:J'Ws5i+.b!\_[CP2nD\HC*v
CBg(#4DLe+.b1ъ*Bp2r%9Y:Oh7ա΋!	Hl?<W>OrAGQ`{FL>!OL'`g$$/4EjfqJ1B*)l6ٿMp.лչL@mIh.6]PO,1Dl4L~ɋ@J7<}iFs5i+.b1IkLIC'+I~vph}OUEK}4@VqzeG'{-F4plTI?rF֔hJuAtXJQx;>VfNr@"=3uw-NFEH/дtF5K@~OqF9tRNNgɆ󝚫N_3haO1FIFS2IEt$c^NIe2$53QB`ϝk(ԺCy&|=HF5ꥂG)]/qNnwmjKDWw? jY>4'r`F$<;{dFP0F:̿,LB)隇AxWObDcq#	ۅ>eL:er=mG)fR
IC0hxU*TK
Ix5i+.b^5N$̈cpH|t$HNOiNㄐi3O<zO1I(
W0\"F-V
ևA)F
Wt חb@Z|KJAVgq@L\J7.jxO`OK #@;>VFhP}N<)ѪF	$aOBd-@y#uLKdqkPCU	.4z]bM
I]Ft
Ox_xrd_w~LNdL֬F4Ku@+К#FlHi"k1%B	T
#8ƪd_NM&uf4Lc'wj5Obx8WFTpj7BWGCQl2FiM^eQI+Idʏ[FFFFF F F!FFF0:s*Dw=F`k;Yi+-z1OY
ȿ4<OV%
X$5I?#3:O4j;Yi+-zj;Yi+-zi;Yi+-zv nr=F>FDF[F"FFF0F1F2F3F%F)F*F0:s*Dw=IFy.Y+FGFHF:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/OFFFFU
8r+C+n4@FacH&8FvCj?e~ҦFFF&FFF	FFk!Pi)?
FFF
F
FFFFFPF%FQFFFF@Fʙ^AiXשFh
Mm8gh
z0Gd<O8mxO4yOԒMm8gh
&FEFǝv\Wސy(_FF4F	Z'B>âRX0eu{ڮP9Vu{0ne0E
Kvne
yOܦϫ|xOjIOQnO09$-1.E^*onePone |~|?ne?PE^#1$-?W2$-?W2$-pw~?neg@ne˳j@ne˳j@ne?W2$-~{S^BEy|KDphKΔӳOհrIOC'zO{TxhO{lhO6ǀ_`\`OOrOh7y)
Oh7BTyI6EZ{ْ?i]?9A!8ҏFs%E~2]r?jdN&6u^gO!B>9}Nr*GݓkFN]ͷghhϓgAc*^Z%Ȕ2AeqKW';?B@
J$SQ`Ɔ(œO>1s-O(hHjxOiQD(ߥl+ rˆLmCBUa{Ӱ~C.`1y/DĊYF;aAdƼ403bpc(Jg
Дէ{E]E)ПS-oEH?syYz(y
K@AXGA'qQUAJ
sY!WOZ{*lg(M2(TfC'>|a. 	O;O.K[K8H]҇26 -&{-r:
%wCjW'tVamy!@iaWBVm`ɠI-`:Bn5OC(K鞟^ﯘ=ѕK0:ښL%2J4{[kYs=BMQ!B\[/B{NsASÖ.̆I#t9JDf?kјH"tŻ-Gs?zZAe!`[ǽ6NXX$KiiőԞ(LqmjKH(.~,-Y@o3\.QCpg{LKIs<_z\
LKo(t;sM|@)^vJYӞ~+IzÊChsxDpWJ?,CP0DOAoZ\q"tDk׾TLrTIkE
a`NNe76_I|kHrYM>s:
.jxOˡd:aDX7iii9P5}+EutX(T6QB~ۜC]_#ͼ_Ld=xr|խhG2`?uIp4Bf6חKt3OtaG'"v0
SNwL1"(iv@	YGح+ObC4`[ԄLr?RJ{,AsEOWL"O7v8yOhKKt&1Zs~:6B}Ftr⋪GMv2̤pDʹfD.b[GvtH;
zr\GڙYkH?FA&OA;,Ui6
IJ"x9J4ܵ;EfDװqmrE.1!YuY&HxHϣ'GVBeUNOخ|)IE@0lyדسDg,ݠeL3"5/QqCAwSk5X;-3B{_41lxpOh6ǾƱLb
VBPoz5zD #D@Fgm[M/BT|\?@zpDF[0	49Z
I}AaB}KX䌠%D|DZ#`ڽWvGE>ςZ#@k{X8&oIQd5CvSdn0@DH&'E4VwҁnB*O&-bfMlV!j

hFXapf_:qJ?򥸿2cpF^W5}3ƔHjiOY<0G==
6eFpqFwHҶe_K#q}kdO-pV+UN;;z5Og5е.Í}DwMm3sG%`4n.8E40yvF'6я]A.VGމJ=PpZd1FOЊĽFK6eJ7`, :i+00Fh3MnMܙS{5)xKt	O3CKsw`$D&l;0MHֿRUBu(dT&arrCuƋ.|uU:WPHw[ێ	Z܊M`* !sG3^F0MJSkyZ
8y
M3,/KqI\M;TQ'CHCh4-6C$/`zLbeLWwR"F)JȬ
պFD-ʀr33yHȅF/_~_INK
R(N伽I@܏Uo#RHkM?'kaIõ}EFVxCEg{Sl"vM`3)/#RW$ZI/Փg3wB$hŨ"IΕL?vk΄e}IƼ8-F"DDm'Cb**+C,R[09|)J=AxB:RC%jAyiȳO^7q2hK_Lrz=*Fŗ5WIZgnMI/~o&
IFk"t% 0H Ng4f/`CU7%(Lx#h>5qM?w;E9eZJ	57BxsCU3@@@@@@8@advapi32api-ms-win-core-fibers-l1-1-1api-ms-win-core-synch-l1-2-0kernel32EventRegisterEventSetInformationEventUnregisterEventWriteTransferFlsAllocFlsFreeFlsGetValueFlsSetValueInitializeCriticalSectionExP@`@h@x@@@@@@@@@@@@@@@ @$@(@,@0@8@D@H@L@P@T@X@\@`@d@h@l@p@t@x@|@@@@@@@@@@@@@@@@@@@@@@
@ 
@8
@X
@x
@
@
@
@@ @H@h@@@@@@@@@ @0@P@p@@@@@8@`@@@@@@@0@P@h@@__based(__cdecl__pascal__stdcall__thiscall__fastcall__vectorcall__clrcall__eabi__ptr64__restrict__unalignedrestrict( new delete=>><<!==!=[]operator->*++---+&->*/%<<=>>=,()~^|&&||*=+=-=/=%=>>=<<=&=|=^=`vftable'`vbtable'`vcall'`typeof'`local static guard'`string'`vbase destructor'`vector deleting destructor'`default constructor closure'`scalar deleting destructor'`vector constructor iterator'`vector destructor iterator'`vector vbase constructor iterator'`virtual displacement map'`eh vector constructor iterator'`eh vector destructor iterator'`eh vector vbase constructor iterator'`copy constructor closure'`udt returning'`EH`RTTI`local vftable'`local vftable constructor closure' new[] delete[]`omni callsig'`placement delete closure'`placement delete[] closure'`managed vector constructor iterator'`managed vector destructor iterator'`eh vector copy constructor iterator'`eh vector vbase copy constructor iterator'`dynamic initializer for '`dynamic atexit destructor for '`vector copy constructor iterator'`vector vbase copy constructor iterator'`managed vector copy constructor iterator'`local static thread guard'operator ""  Type Descriptor' Base Class Descriptor at ( Base Class Array' Class Hierarchy Descriptor' Complete Object Locator'CV: ::template-parameter-generic-type-`'`anonymous namespace'''`non-type-template-parametervoid`template-parameter...NULL%d`template-type-parameter-`generic-class-parameter-`generic-method-parameter-}' }' `vtordispex{`vtordisp{`adjustor{`local static destructor helper'`template static data member constructor helper'`template static data member destructor helper'static virtual private: protected: public: [thunk]:extern "C" ) char short int long unsigned void volatilestd::nullptr_t std::nullptr_t,..., throw(cpuamp, charshortintlongfloatdoublebool__int8__int16__int32__int64__int128char16_tchar32_twchar_t__w64 UNKNOWNsigned const volatile`unknown ecsu'union struct class coclass cointerface enum volatile const & && cli::array<cli::pin_ptr<)[{flat}{for s @,@,@,@ @'@@@@(@\@@ @'@@@@'@@\@ @ (@@@ ?? EEE50P( 8PX700WP  `h````xpxxxxEEE00P('8PW700PP (`h`hhhxwpwpp(null)(null)
		


!
5A
CPR
S
WYl
m pr	

	
)

Tc-^k@tFМ,a\)cd4҇f;lDِe,BbE"&'O@V$gmsmrd'c%{pk>_njf29.EZ%qVJ.C|!@ΊĄ'|Ô%I@T̿aYܫ\DgR)`*!VG6K]_܀
@َЀk#cd8L2WBJa"=UD~ $s%rс@b;zO]3AOmm!3VV%(w;I-G 8NhU]i<$qE}A'JnWb쪉"f37>,ެdNj5jVg@;*xh2kůid&_U JW
{,Ji)Ǫv6UړǚK%v
	t:H孎cY˗i&>r䴆["93uzKG-wn@_l%Bɝs|-Ciu+-,W@zbjUUYԾX1EL9MLy;-"m^8{yrvxyN\lo};obwQ4Y+XW߯_w[R/=OB
R	E]B.4o?nz(wKgg;ɭVlH[=J6RMq!	EJjت|Lu<@rd6x)Q9%0+L;<(wXC=sF|bt!ۮ.P9B4Ҁy7P,=87MsgmQĢR:#שsDp:RRN/M׫
Ob{!@fu)/wdq=v/}fL3.
iLs&`@<
q!-7ڊ1BALlȸ|Rabڇ3ah𔽚j-6zƞ)
?IϦw#[/r5D¨N2Lɭ3v2!L.2>p6\BF8҇i>o@@w,=q/	cQrFZ**F΍$'#+GK	ŎQ1VÎX/4Bycg6fvPbag
;s?.❲ac*&pa%¹u!,`j;҉s}`+i7$fnIoۍut^6n16B(Ȏy$dAՙ,C瀢.=k=yICyJ"pפldNnEtTWtøBncW[5laQۺNPqc+/ޝ"^̯p?m-}oi^,dH94X<H'W&|.ڋu;-Hm~$P	
%-5	>
H
R]iu
-C	Y	p	



	%
d'@Bʚ;minkernel\crts\ucrt\inc\corecrt_internal_strtox.h__crt_strtox::floating_point_value::as_double_is_double__crt_strtox::floating_point_value::as_float!_is_doubleINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanSNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)Visual C++ CRT: Not enough memory to complete call to strerror.Visual C++ CRT: Not enough memory to complete call to strerror..exe.cmd.bat.com./\?*	Runtime Error!

Program: <program name unknown>...

Microsoft Visual C++ Runtime Library(@\)@\/ )@/mscoree.dllCorExitProcess)@v@)@(@v@*@(@\@ *@(@@8*@(@l@P*@(@`@LC_ALLLC_COLLATELC_CTYPELC_MONETARYLC_NUMERICLC_TIME	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=;;=C_.,_.@`@@d@X@\@@<@`@|@@@'@|'@@4@@@4@L@@D@H@@@@\\\.\.TMPTMPmsvcrt.dllccsUTF-8UTF-16LEUNICODEccsUTF-8UTF-16LEUNICODE@-@-@@-@.@`.@.@/@@P/@/@/@0@`0@0@ 1@p1@@8@1@api-ms-win-appmodel-runtime-l1-1-1api-ms-win-core-datetime-l1-1-1api-ms-win-core-file-l2-1-1api-ms-win-core-localization-l1-2-1api-ms-win-core-localization-obsolete-l1-2-0api-ms-win-core-processthreads-l1-1-2api-ms-win-core-string-l1-1-0api-ms-win-core-sysinfo-l1-2-1api-ms-win-core-winrt-l1-1-0api-ms-win-core-xstate-l2-1-0api-ms-win-rtcore-ntuser-window-l1-1-0api-ms-win-security-systemfunctions-l1-1-0ext-ms-win-kernel32-package-current-l1-1-0ext-ms-win-ntuser-dialogbox-l1-1-0ext-ms-win-ntuser-windowstation-l1-1-0user32AreFileApisANSICompareStringExEnumSystemLocalesExGetActiveWindowGetCurrentPackageIdGetDateFormatExGetEnabledXStateFeaturesGetFileInformationByHandleExGetLastActivePopupGetLocaleInfoExGetProcessWindowStation	GetSystemTimePreciseAsFileTimeGetTimeFormatExGetUserDefaultLocaleNameGetUserObjectInformationWGetXStateFeaturesMaskIsValidLocaleNameLCMapStringExLCIDToLocaleNameLocaleNameToLCIDLocateXStateFeatureMessageBoxAMessageBoxW
RoInitialize
RoUninitializeSetThreadStackGuarantee
SystemFunction036am/pma/p -
:	+% 8@$8@(8@,8@08@48@88@<8@D8@P8@X8@h8@t8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@8@9@9@9@(9@49@89@@9@P9@h9@x9@9@9@9@9@9@9@9@9@9@9@9@:@ :@8:@@:@H:@P:@X:@`:@h:@p:@x:@:@:@:@:@:@:@:@X:@:@:@;@;@(;@8;@P;@d;@l;@x;@;@;@;@SunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssSunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssen-USINFinfNANnanNAN(SNAN)nan(snan)NAN(IND)nan(ind)e+000         (((((                  H 	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~         (((((                  H      (                          0SunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecTZE@F@F@8F@HF@hF@F@F@F@F@F@G@(G@@G@XG@hG@xG@G@G@G@G@G@G@G@H@(H@hG@PH@`H@xH@H@H@H@H@H@hG@H@hG@I@ I@8I@XI@pI@hG@No errorOperation not permittedNo such file or directoryNo such processInterrupted function callInput/output errorNo such device or addressArg list too longExec format errorBad file descriptorNo child processesResource temporarily unavailableNot enough spacePermission deniedBad addressUnknown errorResource deviceFile existsImproper linkNo such deviceNot a directoryIs a directoryInvalid argumentToo many open files in systemToo many open filesInappropriate I/O control operationFile too largeNo space left on deviceInvalid seekRead-only file systemToo many linksBroken pipeDomain errorResult too largeResource deadlock avoidedFilename too longNo locks availableFunction not implementedDirectory not emptyIllegal byte sequence+I@I@I@I@ja-JPzh-CNko-KRzh-TWO@ENUO@ENUO@ENUO@ENAP@NLBP@ENC0P@ZHH8P@ZHI@P@CHSPP@ZHHxP@CHSP@ZHIP@CHTP@NLBQ@ENU8Q@ENAPQ@ENLpQ@ENCQ@ENBQ@ENIQ@ENJQ@ENZR@ENS0R@ENThR@ENGR@ENUR@ENUR@FRBR@FRCR@FRLS@FRS8S@DEAXS@DECS@DELS@DESS@ENIS@ITST@NOR T@NORHT@NONpT@PTBT@ESST@ESBT@ESLU@ESO0U@ESCXU@ESDU@ESFU@ESEU@ESGV@ESH(V@ESMHV@ESNhV@ESIV@ESAV@ESZV@ESRV@ESU W@ESY@W@ESVhW@SVFW@DESW@ENGW@ENUW@ENUAW@USAW@GBRW@CHNW@CZEW@GBRX@GBR X@NLD0X@HKGHX@NZL`X@NZLhX@CHNX@CHNX@PRIX@SVKX@ZAFX@KORX@ZAFY@KOR0Y@TTOW@GBRXY@GBRxY@USAW@USAamericanamerican englishamerican-englishaustralianbelgiancanadianchhchichinesechinese-hongkongchinese-simplifiedchinese-singaporechinese-traditionaldutch-belgianenglish-americanenglish-ausenglish-belizeenglish-canenglish-caribbeanenglish-ireenglish-jamaicaenglish-nzenglish-south africaenglish-trinidad y tobagoenglish-ukenglish-usenglish-usafrench-belgianfrench-canadianfrench-luxembourgfrench-swissgerman-austriangerman-lichtensteingerman-luxembourggerman-swissirish-englishitalian-swissnorwegiannorwegian-bokmalnorwegian-nynorskportuguese-brazilianspanish-argentinaspanish-boliviaspanish-chilespanish-colombiaspanish-costa ricaspanish-dominican republicspanish-ecuadorspanish-el salvadorspanish-guatemalaspanish-hondurasspanish-mexicanspanish-modernspanish-nicaraguaspanish-panamaspanish-paraguayspanish-peruspanish-puerto ricospanish-uruguayspanish-venezuelaswedish-finlandswissukususaamericabritainchinaczechenglandgreat britainhollandhong-kongnew-zealandnzpr chinapr-chinapuerto-ricoslovaksouth africasouth koreasouth-africasouth-koreatrinidad & tobagounited-kingdomunited-statesACPOCP6-h@h@h@h@(h@0h@8h@@h@	Hh@
Ph@Xh@`h@
hh@ph@xh@h@h@h@h@h@h@h@h@h@h@h@h@h@h@h@ h@!i@"W@#i@$i@%i@& i@'(i@)0i@*8i@+@i@,Hi@-Pi@/Xi@6`i@7hi@8pi@9xi@>i@?i@@i@Ai@Ci@Di@Fi@Gi@Ii@Ji@Ki@Ni@Oi@Pi@Vi@Wi@Zj@ej@j@j@(j@8j@I@Hj@Xj@hj@xj@	;@j@j@
j@j@j@j@I@I@j@j@k@k@(k@8k@Hk@Xk@hk@xk@k@k@ k@!k@"k@#k@$k@%k@&l@'l@)(l@*8l@+Hl@,Xl@-pl@/l@2l@4l@5l@6l@7l@8l@9l@:m@;m@> m@?0m@@@m@APm@C`m@Dxm@Em@Fm@Gm@Im@Jm@Km@Lm@Nm@On@Pn@R(n@V8n@WHn@ZXn@ehn@kxn@ln@n@n@I@n@	n@
n@n@n@o@o@(o@8o@Po@,`o@;xo@>o@Co@ko@o@o@o@	o@
p@p@ p@;8p@kHp@Xp@hp@xp@	p@
p@p@p@;p@p@p@p@	q@
q@(q@8q@;Pq@`q@	pq@
q@q@q@;q@q@	q@
q@q@;r@  r@	 0r@
 @r@; Pr@$`r@	$pr@
$r@;$r@(r@	(r@
(r@,r@	,r@
,r@0s@	0s@
0 s@40s@	4@s@
4Ps@8`s@
8ps@<s@
<s@@s@
@s@
Ds@
Hs@
Ls@
Ps@|t@|t@arbgcazh-CHScsdadeelenesfifrhehuisitjakonlnoplptroruhrsksqsvthtruridbesletlvltfavihyazeumkafkafohimskkkyswuzttpagutateknmrsamnglkoksyrdivar-SAbg-BGca-EScs-CZda-DKde-DEel-GRfi-FIfr-FRhe-ILhu-HUis-ISit-ITnl-NLnb-NOpl-PLpt-BRro-ROru-RUhr-HRsk-SKsq-ALsv-SEth-THtr-TRur-PKid-IDuk-UAbe-BYsl-SIet-EElv-LVlt-LTfa-IRvi-VNhy-AMaz-AZ-Latneu-ESmk-MKtn-ZAxh-ZAzu-ZAaf-ZAka-GEfo-FOhi-INmt-MTse-NOms-MYkk-KZky-KGsw-KEuz-UZ-Latntt-RUbn-INpa-INgu-INta-INte-INkn-INml-INmr-INsa-INmn-MNcy-GBgl-ESkok-INsyr-SYdiv-MVquz-BOns-ZAmi-NZar-IQde-CHen-GBes-MXfr-BEit-CHnl-BEnn-NOpt-PTsr-SP-Latnsv-FIaz-AZ-Cyrlse-SEms-BNuz-UZ-Cyrlquz-ECar-EGzh-HKde-ATen-AUes-ESfr-CAsr-SP-Cyrlse-FIquz-PEar-LYzh-SGde-LUen-CAes-GTfr-CHhr-BAsmj-NOar-DZzh-MOde-LIen-NZes-CRfr-LUbs-BA-Latnsmj-SEar-MAen-IEes-PAfr-MCsr-BA-Latnsma-NOar-TNen-ZAes-DOsr-BA-Cyrlsma-SEar-OMen-JMes-VEsms-FIar-YEen-CBes-COsmn-FIar-SYen-BZes-PEar-JOen-TTes-ARar-LBen-ZWes-ECar-KWen-PHes-CLar-AEes-UYar-BHes-PYar-QAes-BOes-SVes-HNes-NIes-PRzh-CHTsrj@B`i@,`@qh@p@@@@@@Ђ@@@@@ @0@C@@P@`@Hi@)p@@ki@!@ch@@D@}Ѓ@h@@E(h@@G@0h@@H8h@(@8@H@IX@h@j@Ax@@h@@JHh@@@@Ȅ@؄@@@@@(@8@KH@X@Ph@	h@x@@@@@ȅ@؅@@@@@(@8@H@X@h@x@@i@#@ePi@*@l0i@&@hXh@
Ȇ@Lpi@.؆@s`h@@@@@M(@8@i@>H@i@7X@hh@h@Nxi@/x@th@@@Zph@
@O@i@(@ji@ȇ@axh@؇@Ph@@@Qh@@Rhi@-@ri@1(@xi@:8@h@i@?H@X@Si@2h@y(i@%x@g i@$@f@Xi@+@m@i@=Ȉ@i@;؈@i@0@@w@u@Uh@(@8@TH@h@X@i@6h@~h@x@Vh@@W@@@ȉ@h@؉@Xh@@Yi@<@@@v(@h@8@[i@"H@dX@h@x@@@@h@@\t@Ȋ@@@@h@(@8@]i@3H@zj@@X@i@8h@i@9x@h@@^@nh@@_i@5@|W@ ȋ@bh@؋@`i@4@@{8i@'@i(@o8@H@X@h@x@@@F@paf-zaar-aear-bhar-dzar-egar-iqar-joar-kwar-lbar-lyar-maar-omar-qaar-saar-syar-tnar-yeaz-az-cyrlaz-az-latnbe-bybg-bgbn-inbs-ba-latnca-escs-czcy-gbda-dkde-atde-chde-dede-lide-ludiv-mvel-gren-auen-bzen-caen-cben-gben-ieen-jmen-nzen-phen-tten-usen-zaen-zwes-ares-boes-cles-coes-cres-does-eces-eses-gtes-hnes-mxes-nies-paes-pees-pres-pyes-sves-uyes-veet-eeeu-esfa-irfi-fifo-fofr-befr-cafr-chfr-frfr-lufr-mcgl-esgu-inhe-ilhi-inhr-bahr-hrhu-huhy-amid-idis-isit-chit-itja-jpka-gekk-kzkn-inkok-inko-krky-kglt-ltlv-lvmi-nzmk-mkml-inmn-mnmr-inms-bnms-mymt-mtnb-nonl-benl-nlnn-nons-zapa-inpl-plpt-brpt-ptquz-boquz-ecquz-pero-roru-rusa-inse-fise-nose-sesk-sksl-sisma-nosma-sesmj-nosmj-sesmn-fisms-fisq-alsr-ba-cyrlsr-ba-latnsr-sp-cyrlsr-sp-latnsv-fisv-sesw-kesyr-syta-inte-inth-thtn-zatr-trtt-ruuk-uaur-pkuz-uz-cyrluz-uz-latnvi-vnxh-zazh-chszh-chtzh-cnzh-hkzh-mozh-sgzh-twzu-za01#INF1#QNAN1#SNAN1#IND:Yw/Ml;Zx0Nm?&{?x?5q(7>PD?%>b?>@??`??UUUUUU???UUUUUU????TUUUU?ƺ?Q#Ib?]4? ?0wG?`!?@?@Y?]??i?`÷?0?v?0ϸ?@'?m?ع?Щ0?_?pߺ?6?䍻?0?@:?p??}?? ?0>?0i?@A?pc?l?D???0Q?P-?PIO?@p?0?@'?I?X?S?`:7?`X?x?p|??Н??0s?;?P[?`&|???pw?`??P?p(?7?0kE?S?+b?p?@~?`? R??๷???P?2? ??pD?B?9(?*6?PD? "
=
.3i=W~
=imb;D=W>6Z=y+>>IԭwJ=07?v>Gb=M>Q=z	>p=QW.>n[>p)=m6W>OJK>C>*f>8=pT=:		r>]'p>qw>`
'>M>[^j7>Kb|j>:bβ>	>ޔ0>1k>A>+^=lg=)>,ļ,+>De}=7W`@>`z>~|'e>_M>`>1<.	/>:+>Os&>൏=MǛ/#>yHs=nX>JR!>11Y@/>58d%>_>)MJ$>" >	H*>eVM>cQ6!>6'Yx=%R>jtm}S=`
'>Z>U&>䮿Y
>?h/>77:ݸ$>a~>I{,>Y)>6{1n>Ur	Vr.>Tz3&>Ra+f)>0'C>6Zd >'4
>yU>^!-=j
c?>cQ.>5b#)>^x8o2>Lj[;>vj"=:1J<>s|d>f3>fvw=>;H9>&X;>7Y9>>
'S5>*StO9>T'4>KZ>`'>%%>΋.>Tu
.(!>ʧY3p
>%@~+>!n03>Pu?>d׌5>>t"v:>R=>X̤/>
Ң;>[ >["`=>7>ː#>>6>\.>9Ir,>X>z8>4&/>	VYS9>HVo6>a"$>S= 5>VaR:>V8>(.0>D=Yc%>2x.&>>=K~Je#>!Ix[>dn-/!>9٭7>qb(>aIbQ=cQ61>v+M<7>=*>!ư*>f[t0>To ->Or=)a?>ė=l(>>
"Ic(>\,=F	ET5>m0;>9lߙ%>6>ȨmG4>?7>*y
W3>ay;>V>bp(=>?gҀ8:>})36,>8!> ;>PӽD8>j`&‘+>+&z*>nOv>h=O>yu`=GQ~f=oj37>k>/>dn9>hS=q)i5>m"e=?~X3>6>Tz36>J`?>!T4<>0A8>cքBC?>6t9^	c:>VB4>ٲ6>*:8'>0<>Rm=1>"3>PkY)>'._M
>5*=4<,BF>^G*>`JK&>.yCB
)>O 'L>[.xJ>Hfy\PD>!MԩL>|b=})>\ >vc [1>H')>dL?>Z|F>Ni;>_j+>yC>O@L)>uzKs@>D>He@>5A3>N;kUr=CA	 >	p.>EK>VR>>e	kE>fvwM>`7nH>eF>tH/>ѤL>ev[%>J
A>@
_A>pP&V6E>`"(5~7>ҹ@0$>y{@>W9oM>WL>փJ>W
p0>
lD>#,=>B_!">}tM>'>+Ai=1I!>u|KN>
c0iN>/پA>+h->|ۈ:>r-4@>%>b?>@ ??? ?۠c?qBJeD?
#D%?|?E??z?g1?Pt?t:W?sy:?????ہv`?#?4,Tw?ru\?AA?[,'?tn?ƿD\n?V?m?^?BZ&?qq?I
єX???.9&???+?{>e?к?#+?3=l}?e?O贁N?JH7?ـl@6 ?"1K	?(?^?pp?/?cj`?Y0Q?mЦm?JhAW?AA?Ň*,?Kz??3?-hk?N?U$??
/?rp?w\?H?,4?)I ?ՐO
???7zR?0?:bο?k??J?'t?aa?xO?ݾz?[R֯?Jv?gв9?H"?{Gz?f`Y4m?`?vS?beF?M0':?%f-?QY^& ??feт???B?,?u?{?U)#`?;;?"z8$?c,?f"?88?E[u?Hi?*_]?x+R?FyF?W[:?j\/?+J#?Xw?0
?`*?h/?KN?K%?P-
?,M?7Z?@+??)A?[r??MΡ8}?5'Ps?'|h?p"^?w~S?$I$I?[`>?߼xV4?*"*?x!?UHy?gG?  ?p}?Ljm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfa`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

@@HN	

#+3;CScs	
!1Aa 0@` inflate 1.2.8 Copyright 1995-2013 Mark Adler  @0@@@@P@`@p@@@@invalid distance too far backinvalid distance codeinvalid literal/length codeincorrect header checkunknown compression methodinvalid window sizeunknown header flags setheader crc mismatchinvalid block typeinvalid stored block lengthstoo many length or distance symbolsinvalid code lengths setinvalid bit length repeatinvalid code -- missing end-of-blockinvalid literal/lengths setinvalid distances setincorrect data checkincorrect length checkneed dictionarystream endfile errorstream errordata errorinsufficient memorybuffer errorincompatible version *PXZ *PXpp *PX
@@@@ЍH `xЍ@H@H `x@H88@`H `x`@H@RSDSm>0JHȧE:\CPython\cpython35\lib\distutils\command\wininst-14.0-amd64.pdbGCTLp.text$mnp .text$mn$00.text$x.idata$5.00cfg.CRT$XCA.CRT$XCAA.CRT$XCZ.CRT$XIA.CRT$XIAA.CRT$XIAC .CRT$XIC.CRT$XIZ.CRT$XPA.CRT$XPX0.CRT$XPXA8.CRT$XPZ@.CRT$XTAH.CRT$XTZPX.rdatal.rdata$rd.rdata$zzzdbgx.rtc$IAA.rtc$IZZ.rtc$TAA.rtc$TZZ|p.xdatad.idata$2d.idata$3d.idata$4`j.idata$6
.data.data$r=.bssZ.pdata0	.gfids$x0	.gfids$y@	0.rsrc$010A	(.rsrc$02dT42p
dT4pd4p7
&t;&d:&49&2P@d	4RpRp`0d	4Rpd
T	4Rpd	4RpRp`0bp
`P0d	4RpRp`0T42p20

4
2p'	T9482p`@d
T	4Rptd
T	42BB
4,
*p@@&4ZXP@&4ZXP@
42
p`P*%4#
p`P@h
4rp`
Ptd
T	422
 t# d" T! 4  @
4
p@P+p`0@0d4
rp

4
Rp.t1d0T/4.,@P p`P0@9((t(d(4(P@
4

p@@!0@0(	d342,pP@P

4	
Rp204"1"t0"T/"*@@7
&&&t&4&P@+@@#p`P@0)	32d1.P@` 4&$P@B@@+T4
@0&4dbP@dT
4RpdT
4Rp2020d4
p@@=
,t,d,4,P@PR0t4t
d4t
d4)	t*d)4(&P@ 	B
	p`P0dT42pd42p
t	dT42	
	p`0P20d42pdT42pd42p
d
T	42p*4 
p`P@BbB		b

4

rprp`020B2020BB	

4
Rp|7LL2PBBB20	"|7››PB202020

4

rPdT42pBBBBBB

4	
2PBB4PBd42pd42pt42P""dT4rpBBBBB20dT4rp20202020BBBd42p20B20B20202020
t	dT42
t	dT42

4
2p
td
T	4R

4
2p

4
2p

4
2pd42pdT42p		2020
t	dT42td
T	42dT4
2pdT4
2p	t d4|)*RP	t d4|*+RPd
T	4Rpbp
`P0d42p

4
2p		2020d42p

4
2pd42pr0@8r0@8

4
2p

4
2ptd42dT42p2020202020

4
2pd42pd42p202020		20d42p20

4
Rp

4
Rp

4
Rp

4
2pd42p

4
2p20d4P20-td4P@td4P+t*d)4(&P

4

rP

4

rptd4P480
p`P1
#t!#d #4#P@-t#d"4!P@??x
4h4&
p	`PBr020

4
P

4
Rp20

4
Pt
4P11x-h't'd'4'Pd
4P04p`Ptd
4P
td
4rPt
4P
td4P#
#t#d#4#PR0d
4pt
4Pd	4Rp20

4
p00202020td4P202020t4P20R020r0t4Pd42p

4
2p

4
2pdT42pdT42pd42p
t	dT4220

4
2p

4
2pd
4	Rp|0102P20td
4	R|012P20B
t	dT4220202042p|55H2P

4
2p2020bb

4
2p|55`2P

4
2p|+686y2Pd42pd42ptd
T	42
td
T	4Rtd
T	422020
t
dT4
r

4
Rp4
rp

R0

4
2pbbb
dT4p
dT4pdT4p		P		P		P2!d!4!pP@

4
Rpt
dT4
R2!d!4!pP@p		P		P		P2!d!4!pP@R0
dT4
Rp2!d!4!pP@p20B

4
2p20

4
2pPPPPPP,	4
p`P@2!d!4!pP@R0

4
Rp
t
d	4R
td4
R,	4
p`P@p2!d!4!pP@pB20
d
T	42p20202020T42p202020T
4	2
p`B
d
T4Rp

4
2pd42pd42p

4

p20d42pd4
p@@20$d4p@BB20
dT
4	2p20202020
	td422020d	T42pB+dT4rp@8d42pd42pd42pt4
20d42pT4Rp`20$d4p@BB2020T42p202020T
4	2
p`B
d
T4Rp

4
2pd42pd42p

4

p20d42pd4
p@@20$d4p@BB2020
	td422020d	T42pB+dT4rp@8d42pd42pd42pt4
20d42pT4Rp`20$d4p@BB

4	
Rp

4	
RpR020d42b2020
d
T	42p202020T
4	2
p`2020B
d
T4Rpd42pd42pd42pd4
p
dT
4	2p

4
2pd4
p@@20$d4p@PBB

4	
Rp

4	
RpR020d42b2020td
T	422020d	T42p2020B+dT4rp@8d42pd42pd42ptd4

dT
4	2p

4
2pT4Rp`20$d4p@PBBtd
T	42202020T42p2020BT
4	2
p`B
d
T4Rp

4
2pd42pd42p

4

p20d42pd4
p@@20BdT4
2p202020
t	dT42d	T42pB+dT4rp@8d42pd42pd42pt4
20d42pdT
4	Rp20,	4
p`P@2!d!4!pP@B20B

4	
Rp

4	
RpR020d42b2020
d
T	42p2020BT
4	2
p`2020B
d
T4Rpd42pd42pd42pd4
p
dT
4	2p

4
2pd4
p@@20B20B

4	
Rp

4	
RpR020d42b2020td
T	42d	T42p2020B+dT4rp@8d42pd42pd42ptd4

dT
4	2p

4
2pdT
4	Rp204444444444
t	dT42"
"t	"d"T"4"24t
4dT42pR0R0R0R0R0R0R0R0R0R0R0R0R0R0R0R044444444R0R0R0R0R0R0R0R0R0R044R0R0R0R0R0R0R0R0R0444444R0R0R0R0R0R0R0R0R0R044R0R0R0R0R0R0R0R0R04442p|MM2P42p|MM2P42p|JMTM2P42p|
MM2P42p|LL2P42p|
NN2P20dT42p2020BT
4	2
p`B
d
T4Rp

4
2pd42pd42p

4

p20d42pd4
p@@2020
t	dT42d	T42pB+dT4rp@8d42pd42pd42pt4
20d42pdT
4	Rp20444444
P@!(
( Ԅtd4 {! {T2p!

d	4 70! 70BBBd
4Rp|a42Pd
4Rp|8N2PPdT4
2pd42pB42p|.9h2PB2020B2020

4
2pR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
RpR0

4
Rp

4
2p

4
2p

4
2pBR0

4
RpR0

4
RpR0

4
RpR0

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
Rp

4
RpBBtd4rPtd4rPBBdT4p
dT4p20R0202020R0d42pd42prp0Prp0Pd42pd42pr0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r02020r0r0d42pb		Pt"d!4 P		P-t(d'4&"P@2020	TG>
`!tFs !4Ds !s !s ?4?!4@ ^P!!t>dA4@ ^P!!t>4@ ^P!!t>4@ ^P!Dp`0@!A!!GGTJ@BCv!!v!!!!
@ABCTJ!04~
p`P@YYCQDIFATG64HIp`!EIl"!Il"bb
t	dT42td
T	42
4Rp`
PdT
4Rp@
/t/d/4/~!P@04xn
p`P@`

4
Rp20

4
2p20

4
2p2020PP-t(d'4&"P@t"d!4 PB20B20d42p

4
2p2020

4
2p

4
2pd42pd42pd
T4rp

4
2p

4
2p20Bd42p2020d42pB20)	t"d!4 P@BB20Bd42p

4
2p2020

4
2pd42pd	4RpBd
T4rp

4
2p

4
2pB

4
2p

4
2pd
T42pd42pd42p
t	dT42

4
2pd42p202020t4PBB20d42p

4
2p20

4
2p

4
2pd42pd42pd
T4rp

4
2p

4
2pB

4
2p

4
2p20

4
2pd42pd	4RpBd
T4rp

4
2p

4
2p20dT42p

4
2pdT42pd42pdT4
2p
4R
p`PB20Btd4P4rp4rp
4r
p`P
4
2
p`PB

4
2pB
dT4p4rp4rp
t	dT42
T4
Rp`Btd4rP4rp4rp
4R
p`Pd
T42pB
dT4p4rp4rp42p|z

2P42p|:
D
2P
4m
hp@0B
4m
hp@0B
4m
hp@0B
4m
hp@0B
4m
hp@0B
4m
hp@0B
4m
hp@0B
4m
hp@0B	p
`0Pbb	p
`0P
4r
p`P	p
`0P

4
2pd
4rpd
4rpbbbb

4
2p  d T 4 rp  d T 4 rpr04
rpd
T4
rp
dT
4rp

4
2ptd
T	42

4
2p
d
T	42p
d
T	42p

4
2pdT4
2p

4
2p
d
T	42p
d
T	42p

t444t
d444

4
Rpd
T	4Rpd
T	4Rp

4
Rp20b

4
Rp

4
Rpd
T	4Rpd
T	4RpB

0P

0P

0P

0P20202020BB
t	dT4220d42p20'	TN4MHp`@0202020
d4pP20
d4pP20
d4pP20
d4pP0
P0
P0
P0
P2020$4
p`P@xT4
rp$4
p`P@xT4
rp$4
p`P@xT4
rp$4
p`P@xT4
rp0B0B0B0B	P@h	P@hd
4p|:,,
2Pd
4p|)s*2Pd4p|n++2Pd
4p|*3+2Pr0r0dT42p
dT4
RpB	J0@@

4
2p4R
p`P4R
p`P20B4R
p`P4R
p`Ptd
T	422020	td42020BBB

4
2p

4
2pBd42pBd42p42p42p2020BB
dT4
Rp
dT4
RpT4
r`T	4R`

4
2pB

4
2p
t	dT42d42pBBB

4
2p2020B20
	td42|q9r$xrq~r?2P2P42
p
`|uuX2PBB
t4d	4Rp20Rp0P	*0@@2
0|@k2P2P
Ptd
T	42-
I
	p`0P@0bp`P0d
T	4Rp
dT4
Rp04qf
p`P@ dT
4Rp)4K@
p`P@B2p|~~2P202020202020BB

4
p20B42p|xx2P42p|w+wo2P

20|MwVw2P42p|wx2PBrPb2020td
T	42BdT4
2pB42p|-7)2P
d4rp|vʓC2PBBBBB2020	20|Xee20BBdT4
rpbb

4
2p
4Rp
`PdT4
RpT4
R
p`20202020
td4
R|Тm`RP
d
T4
Rp2020
td4
R|̣iyRPb

4
2pb

4
2pBd4
rpbbdT
4p##t#4#PB0|rPB0|IvrP

4
p|;_ rP

4
p|?srPBBBbT4
Rp`d42p
d
T4Rpr0r0d	4Rp42
`|7n2P
4
p`P4	b
p`P
0
4R
p`P	b
	p`P0b

4
2p

4
2pBB42p|-m2P

20

4
2p202020B20bR0bR0bR0bR0bbbbR0R0R0R0

4
Rp

4
Rp

4
Rp

4
RpbbB20B.	d4pP@

4

rp
td
T	4R20|Lz2PdT42p2020dT
4pdT
4pt4Pt4P

4
Rpd
T	4Rp

4
2p

4
2p

4
2pd42pt2020
tdT
4d
T4rp
t
dT4
r20
t	dT42
t	dT42

4
2p
td
T	4Rd42pd42pdT42p

4
2p
tdT
4
t	dT42d42pdT42p
t	dT42
t	dT42

4
2p20d42p

4
2p20BB

4
2p
4
p@@

4
2p20
t	dT42
d
T	42ptd
T	42dT4
2p20

4
2p20Bd42p|l2P

4
Rp|A*2P42p|v2P20d42pd4rp|(C6]2P2P2020|
!2P

4
2ptdT4td42B20202P2P2P2P2P2P2P2P2P2020
4Rp`
PdT
4Rpt
d	4RdT42p
td
T	4R
t	dT42

4
2pBB

4
2pd42p2020

20

4
2prPBB		P

RPBBB		rP

4
2p2020d42p42p|2P42p|2P42p|Iy2P42p|1?2P2020Bbbtd4PdT4pdT4pdT4ptdT4d42pd42p204
p`P'E4C
p`P@`BbBBBd4Pd4P

4
2p

4
2pd	pPd	pP
tdT
4

4
Rp

4
pbd4pdT4pBP@
tdT
4dT
4ptdT4
t
dT4
rd4
rpdT
442p|ii2P20!T4
rp`@0		B4Rp|ij'jj'2P20

4
2p		2042p|#n.nA2PBB2p`P04
Rp|	ooYooY2PBBB
d42p|wws2P
4
p`Pd42p(
4
p`P@p
t	dT42-	T4p`@@-	T4p`@@1T4p`@`

4
Rpd42pd42pt	d42Pt	d42Pd	42pd	42pB

4
2p(tdP@pBBBBd42pd42p20d42p

4
2p

4
2p2020d42pd42pB|7=2P20|2PB|Ӗ2P202020

4
2pp`0P4R
p`P$d+4*(p@0dT
4	RpdT4p42p|2P
t	dT42(d4rpP@842p|2P

4
2pBBb
td
4rtdT4

4
2p20R0@($dK4JHp@0dT42pdT42pdT42pdT42p

4
2pdT42p

4
2pdT42pBdT4
rp
dT4
Rp
dT
4rpBtd
4R|
Q72P
td4
R|72Ptd42
t	dT42dT42pd42pt
d	4R|2P2020

4
2p"	
	p`0P@h'

	p`0P@pB2020

4
2p

4
2p
tdT
4
tdT
4
tdT
4
tdT
42020B
4
p`P(
4
p`P@pd42p

4
2pdT42pt
dT4
R%	490
p`P@pd42p

4
2pdT42pdT
4Rp%	4[R
p`P@2020d42p

4
2p|2PB%
T4rp`@8r0dT42p+t4P@p4rp`Pd42pB42p|x2P

4

rpd4
rp
t
dT4
rdT42pB2020B1
dT4p@BBB20202020td4rP2
02020dT4rp

20

4
2pT42`td4rP

4
2p2020d42p-
5td43
P@PBdT42p

20

4
2p|2P

4
2pt
dT4
Rtd
T	42

4
2p'	T4p`@

4
2p$d*4)&p@ 
4!
p@d42p
4
rp@8

4
2p r	p`0P@0
t	dT42

4
2p(	d*4)$
p@

4
2p$d(4'$p@

4
2p)	d)T(4'$p@20d42pd42pBdT42pBdT42pd42p

4
2p20|z2P

4
2p|2PBBB
t	4R|IG2P
p`0|#2PB

4
2p|g
2PB42p|2H2PbR0bR0bR0bR0bR0bR0bR0bR0bR0bR0R020R020R0

4
2pR0

4
2pbb20|++2P20|%,0,2P
t
d	4R|-#.1.F.RP
t
d	4R|.%/3/H/RP
t
d	4R|'o(`}((`RP
t
d	4R|(t)y))yRPd42pdT42pd	4Rpd
T	4Rpt
d	4R
td
T	4R2020B0@HB20d4
rp

4	
Rp|4	5452P2PBB0
P
d
T	42pBB42p|M55)2Pd	4RpB
d42p|*9Z9C2P
d42p|:H:Z2Pd42pd42pBBBB
t
dT4
rBd
T	4Rp	tdT4b20B42p|ABq2PB
tdT
4dT4p20202020r0r0d4p-
Utd4S
P@X20d42p-

	p`0P@td4220B-

	p`0P@t	d42P
td
4	2Pb		bB42p|xx2P2020BBbbbbR0@(d	T42p4
Rp`P@(

4
2pdT42p

4
2pdT42p

P@@

4

rpB$		p`P0@-
Etd4C
P@`BBBBBBBd42pBBd
4r
p|ǑRP

4
2pd	4Rpd	4Rp

4
2p|CZ2P
	td42|d2P
	td42|S2P
td
T	4RdT
4Rp

4
2p
td
T	4Rd	4Rp
tdT
4d4p'US
	p`0P@x202020

hB20B	
td
4	2|V__2PdT
4p
4P
Lp@P0d42p&	h	p`0P@&	h	p`0P@0hbbhbb'	h
4!
p	`P@+x
h4#
p	`P@Bh4R
p`P
0t	d42P20	d	42p|jqEq2PB20	

4
2p|ͻ2P0B20"ejPheZmhin e~ohd"pXi@p@jpooppooooorj`j`oNo>o2o&ooopokll$l8lNl^lrlllllllllmm&m>mw0kkvvvvvrvXv>v2v&vvvuuuuuuuluXuDu,uukkkkxklk\kvDkkkjjjjjjjvtwttttpppppqq8qRqhq~qqqqqqqr*rBrZrrrrrrrrrrss&s6sDsTsvssssssssstt&t8tHtZtjttt0pmtmhmnnnnnnnnrndnVnDn2n nnmmmmmmmm\pnpLpPropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrorSetFileTimelstrlenAUnmapViewOfFileVGetLastError7GetFileAttributesACreateFileACloseHandleCreateFileMappingACreateDirectoryADosDateTimeToFileTimeMapViewOfFileTReadFilehGetModuleFileNameA#SetPriorityClassGetCurrentProcessGetStdHandleLoadLibraryExAiGetModuleFileNameWCSetThreadPrioritySetFilePointerResumeThreadjGetModuleHandleAMultiByteToWideCharGetTempPathAGetCurrentThreadLoadLibraryADeleteFileA0SetStdHandleGetProcAddressLocalFreeBGetFileSizeRemoveDirectoryAFreeLibraryCreateProcessAFormatMessageAGetTempFileNameAGetPrivateProfileIntAGetPrivateProfileStringAKERNEL32.dllEndPaintBeginPaintReleaseDC_UpdateWindow|GetParentoPeekMessageA>GetDlgItemSetCursorSendMessageASetDlgItemTextASendDlgItemMessageAGTranslateMessagepCreateWindowExADefWindowProcARegisterClassAWMoveWindowJMessageBoxA(ShowWindowwsprintfAGetSystemMetricssPostMessageA6GetDC"LoadCursorADGetFocusGetWindowRectDispatchMessageAUSER32.dllVCreateSolidBrushDeleteObjectSetBkModeTextOutASetTextColor7CreateDIBitmapSelectObject=CreateFontAGDI32.dllrRegEnumKeyExAkRegDeleteValueARegOpenKeyExARegSetValueExARegQueryValueA\RegCreateKeyExARegQueryValueExAaRegDeleteKeyATRegCloseKeyADVAPI32.dll3ShellExecuteASHELL32.dllSCoInitializeCoUninitializeCoCreateInstanceole32.dllRtlCaptureContextRtlLookupFunctionEntryRtlVirtualUnwindUnhandledExceptionFilterRSetUnhandledExceptionFilterpTerminateProcesspIsProcessorFeaturePresent0QueryPerformanceCounterGetCurrentProcessIdGetCurrentThreadIdGetSystemTimeAsFileTimeTInitializeSListHeadjIsDebuggerPresentGetStartupInfoWmGetModuleHandleWRtlUnwindExZInterlockedPushEntrySListXInterlockedFlushSList)EnterCriticalSectionLeaveCriticalSectionDeleteCriticalSectionQInitializeCriticalSectionAndSpinCountTlsAllocTlsGetValueTlsSetValueTlsFreeLoadLibraryExWWideCharToMultiByteGetCommandLineAGetCommandLineWCreateFileW&GetDriveTypeWEGetFileTypePeekNamedPipemSystemTimeToTzSpecificLocalTimecFileTimeToSystemTimeWriteFileWExitProcesslGetModuleHandleExWGetACPGetConsoleModeRReadConsoleW<HeapFree8HeapAllocGetDateFormatWGetTimeFormatWCompareStringWLCMapStringWZGetLocaleInfoWwIsValidLocaleGetUserDefaultLCIDLEnumSystemLocalesWSetEnvironmentVariableASetEnvironmentVariableW?HeapReAllocGetConsoleCPGetStringTypeWGetTimeZoneInformationSetCurrentDirectoryW	GetCurrentDirectoryWPGetFullPathNameWMGetFullPathNameAOutputDebugStringAOutputDebugStringWWaitForSingleObjectExCreateThreadnFindClosesFindFirstFileExAtFindFirstFileExWFindNextFileAFindNextFileWuIsValidCodePageGetOEMCPGetCPInfo.GetEnvironmentStringsWFreeEnvironmentStringsWGetProcessHeapSetConsoleCtrlHandler9GetFileAttributesExWSetEndOfFileSetFilePointerExFlushFileBuffersWriteConsoleWAHeapSizeGetTempPathWDRaiseException2-+] f/    DB@


@=@(@(@(@(@(@0@?@@A@`5@@@C@=@BB@PSTPDT@@@                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ@`y!@~ڣ @ڣ AϢ[@~QQ^ _j21~                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZЊ@@@@@@@@@@Ԋ@@@@@@@@0@..u@@@@@@@ȫ@ԫ@@@Ь@@@@(@@@P@h@x@Software\Microsoft\Windows\CurrentVersion\UninstallSoftware\Microsoft\Windows\CurrentVersion\Uninstall`@L @p@@@X#@@@@@@"@@@@@@@@ȫ@ԫ@@@.?AVDNameNode@@@.?AVcharNode@@@.?AVpcharNode@@@.?AVpDNameNode@@@.?AVDNameStatusNode@@@.?AVpairNode@@@.?AVtype_info@@J\>@(<RLTXhBxT2H
K L " "X#8h#$@$K&XL&(p(**m+p+n-p-L.L.000 0K10L1	3<3L3`L34h48686667799::<:::@?@?C(C:DP{>>>>>>??3?x?????@$@@@1B^p,@^^,^K_d-L__8-_x`-x`a,aa\-a&b -(bb|-bcX+cd`+diP(is(sw@)w),P-т,Ԃol-pl(\)T(T)x(;h)<ڇ(܇z)|,(,)(ȏt)ȏ ( )v(x7)'a'd'M'řX*ș*F*H+šx*Ě*C*D8+$- $0&`}%# D_#`}l&Рt&
'+d&,G#H|# +,%},@|&-,Ȩ?,@(#@!ԯ$,%,e"h""#P#_t#x#Il"I|"|"@(Q($
8%|T&%M'&!v!v!""$" ^P!^~X!~l!!!0H"9H!X4($4"&$H%8'Li`$l&t%X'L$L'&%('D$D'%U'XL$"l%dT$g&p8$&qX%t)D',l$5&8%Pd'PD$&d%:P'<W#Xq$tH&V" 		$	%$X$%$ &s s !$ !$]0!"d0&`H((Lj$l@%$"%$P8(P|(|8))$%0%(V&X0'E|$`&%nt'
$$'%'      ! !
# #M#x P##h #|$-|$:%-<%%-%&.&&-&	'-''-'{(-|( )- ))-)*0*L+L1L+,1,,0,-d0-.-00-V-t0X-~-0-q.l/t.g/x/h/e0/h0[1/\11.1`3.`33/3k5/l55,/574/77L/79T/9H:/H::/:; 0;;<L0<<>/>?/@A0AC00CD0DHE0HEE|1EE1FF/FG. GG\0GUH|0`HHl0(II0IVJ.XJzJ/|JJ.JJt.JJ|.J(L.4LL.LM.4N=O.HOcO.dOTP$.TPFQ0.HQDRH.DR6S<.8SST.SS\.S>Tl.@TTd.TV1VV1V\W1\WY1YZ1@Z[2[],24]^@2^`l2``\2``2aad2aa2aa2aIb2Lbc1c5e1Heie3lee$3ee3ef3 ff2ff2LgEh,3HhKiD3Lii2ii3ij\3jhkl3kk2k=l2@lZl2\lvl2\mm2mm2mm2mln3nn3ndo|3o*p3,pxp3pp3q-q30qDq3Dqr4rr4s\s3\ss3ss38t|t3tt4tu4uuX4vv4v=w6@wiw6lwx7xx6xyh6y6y68y^yp6$z?zH6@z[z86\zwzX6z:{x6<{Y|6|}P6}/}@60}K}`6P}}4}'~6(~~x5~546'4($H5$Ɔ4Ȇ4̈,5̈1h54Љ$5Љ5?5@~5@7K7L77:7X77h7#`7D~P7H7?,8HX48`<8JD88$8К8t8Dl8DkL8|8ޜ8ß8ğ8998X9Χ9Ч99*9d8p99Ъ89ǫx9ȫ988X9S9XD:Ǯt:Ȯ::h@;3:4:;;w;xƷ;ȷ0;<:X;::l:%`;0 : R9Tɾh;̾b;d;;;x;
;D<<<4< (<=<@<|x<|p<<~<<Q<T<0,=0lD=l8=P==C$=Dw=x==
<6<8k<l<<<*<,_<`<<<==@Z|=\="\=$Sd=Tl=t=3>4==>\>uh>x%<>(L>X>(>A4A,Ax$AA@l@l8@8:@<@>>b>d|>>i>l>>?s?t,?dD?d P? h?x?t?t?g?hW?X?4?4?C@D,@8@4@@4P@\@d@>l@@t@>@a@d>ZdA#A$oA|`A`A B\BxB3(B4tPB|BBuBxB
BBB
B9BlBBB B<sBBCz0C|nXCpDC~pC"C,DDXDQDTzD|CDC`zC|8DDd )!C,!!C" "C "#D#
$$D$$,D$!%HD0%K%@DL%%C%	&C&&C&?'C@'y'C|''C''E'(E((F(H)EH):*E<*_*E*C:EH:;EH<AEApCLEpCEhEEgMEhMMFM,O0E,OKOELOjO(ElOO EOO FOPFP5RpF8RRXFRRdFSBT8FHTUHFUU0FUU(FU(WF0WWFW(YF(YuYFxYYFZ]]$\>?,\`?'@`\@bAL\dAAD\A$B\$BJB\lBB\BqCx\tCD\D9E\TETF\TFF\FF\FF](GTG]TGG]G!H]H7L0]8LL ]LMX]M	_]_>_]@_T_]`g`]h`sp]s[t`]\tv]vw]xx^xx^(ycy^dyy^y!zD^`zwzT^xzz\^zzL^z+|^,|}^}-~^0~~^~I^L^h^ht^|^׀d^؀l^_āb_l_$_L_,_|_1t_4ևX`؇z`|lj`ȉ7`8ы`ԋx aԌ`Ԍ`܍`܍aq,`t_/_0G_X_ޒ__;_Hn_p_e0ahXaHa|aa\a ˟a̟a(a^a(\a:aP`b'b(ϦbЦ54b8ttj\VzxYYtdWDEEu*jWEutWhHZFjӃWjYYEuhXEt
WhHZFjӃ\u[3_@^]USVuWEu@EjhPjjhW@E؃HEuUVEYuPt	PXE2WjYYt23PhjPPhW@E؃uWh`ZFWjYYtWjYYEPuu4EEPPPSTE}u	SPK|$u΁?PKuN .D$D$$D$D$ FFD$OD$GȍCL$$3ɉD$8FD@AuL$@QAu+ʍD$@HD$(<\t|$@OGGufZFfD$@PPE|$@3D$0D$98t9ʍAD$Au+L$Qt$$ROwD$G8uNj|$GPt$$D$HPgL$@L$@QAuD$(+ʀ<\tJFT$@h&@PF3Pvt$@t"T$8QvOvQ\]|$,t$}t7ut0}t*t&39EhFYӋU׋_^[]UQEPh\FuFtujhZFF]UQEPh\FuFtujMhZFF]UF3ʼnE=LFVuu:h\FtEuh\F5FFYY3h\FPELFW\FPWVF=LFuh\F5FFYY{34Fd|YYtF
rh]F5F?j4FPjLFtPWFYYh\F5FF3_M3^.^]U0F3ʼnEVuW3WȲEyPh$]F5FFPPPPPPPhD]FVF$u3PhEjWhEIJEyPhP]FxRhpEPyPht]FRPQPyPh]F1PQyPh]F9t!PQ,yPh]F9t'PQDyPh]F9t!PQ$yPh^FhPjWWhEjRPQyFPh@^F5FFtQPtQPElPQPQEhZFFYM_3^[]UEPEPEPhl^FuFt$uuuhEPEPhp^FFYY]54FFYUlF3ʼnESV5|EhFh^FPDž֍PFStEhZF5FE5Fh^FP֋5EPPEPhօt!PPEPhօt3SWOGGufZFfCu+OGGuˍj˃jPE_M^3[;Z]USV5EWh_FWh4_FWEhL_FWEhd_FWht_FWEh_FWEh_FWEh_FWE։EE}}}t{}tu}toh_FЋYt=h_FWh_FWFӃFpFj[jVUP6WUuEFEFEFE䣰F33@_^[]UXF3ʼnEESV5EWh[FS]Eh_FSEh[FSEh[FSEht_FSEhd_FSEh_FSEh_FSE֋uąi}_}U}K}A}7/}%?
hW詀YYuWh_FjYPRjXh`Fh5pFE֋Mhj`FVm}+ljEjZUċtUċȋE3ɉ8UuVjUYY>t6r6YhF|EEPS-YYu*uFJVWSӉ~Wf8
UYEUSEY
j3@e_^[M3W]US]3VW3MPFPuGtYYjhjjVhPE@E5EjjE֋5|EWjEWjWEtuUQ}YYuEEh(`FjYPYYujujjWE;sjWEFP-Yt(3PPPWE\EjEPV3W(EEW{V4t,aF3x܋Nt+F+FSW~++щF+7h'YPhlEtwSjh`aFPEt^3PPP7PjYtU0VWσQAu+ʍFP|YWFFLE3@HEdaF3_[M3^O]UW3EPEEP`EjWWWEPEu_]ULF3ʼnE}SVuWtuuuVEEPVXEjxEj
YhaF3QQQQQQQjhQQQPPEPW4EjWEDEFˍQAu+QS@EjjWhWB]UF3ʼnEPP P PhfFhPP5FF$tPYM3A]U
5F3ʼnEES]VuWN-tc-t-PuhhSEVhSEVjhhSE3@M_^3[)A]FtPjhrhSEh`Fh@fFP|E5EPhShfFhS~1t)~8jjhpSEPtE5EjjhpSpFFPtEjjhkSPEFэrBu+րF\tyGGufZFfQAu+I!F 6\
F5Et9thfFhSg=FhgFhSփu
(gF*=F=PFt:hLgFhShhgFh5pFt3ҋWE=FtD=Ft;h|gFhShhgFh5pFt3ҋBVE3@UF3ʼnE}NS]V}c}=F=FhgFhSDžgFE3ɊF
AuWOGGugFFfBu+OGGuFʃtQhFhgFP-hjlE=EP׉PPYYtPhgFj4YPt
VhSEh(hFhSEVGY_FF3tPVhrhSE95FuPhSEVVhStE3@%Ex8ujjhpSEPtE3M^3[<]UF3ʼnESFEVWj43VPR3u}j4VEPmR=dEE8EV׉EEuЋ5(EPE,@Ek։EEPEElEM0@։EEPEEmE7@։EEPEEnE:@3EVE4׉EEEEP]E uuuE,EM_^3[;]h\FtEu3hxhFPE@FtUXF3ʼnE=Fu3AhFEhbFP|EEPhjEPhEuuE3@M3;]UF3ʼnEjjhZFhFhhFjLE ,P|hhFP|E|jhhFPjEM3:]U-F3ĉ$SVW5F=ED$hFVPhZFhhFSjPT$FpY5FD$VPhZFhhFSVT$FGY5FjPh FhZFhhFS5F5EjhhFS5FPFjhiFS5FFFj
VhZFhiFS5FjPh`FhZFh iFh(iF5FhhFhZFh4iFS5FFj
PhZFhDiFSNFFuZFXiF3ɺF
:uAuun`iF3
:uAuauEt<̀=Ft1hiF3
:uAujhpiFhxiFhEPE^F5TFLEFtPxEFtPHE$3_^[3x8]UEE:utP:Quu3]]U`F3ʼnESVWh3PS$EPhiFPhiFPhiFViFPWVPhiFVPWV@V诿jD^VSPpM3DžfPPhZFSVSSSPSEtO5XEjjpEPhEP E5A@jV=Ej$hjFhjFj׃t334FZF9Ɗ:utP:Quu34PPhkFVuT3
cF:
uAu4FE8jPhkFhEPPPhtkFV\uPPhkFV!utVPPhkFVtɍPPhkFVueHEtZtUCRPPhkFVu	](PPhkFVbuOA;	vxEt	@CHEVMtSPhkFP|EPhDlFP|Ej@hhlFPjwQ3PPhljFPE3@M_^3[/]0SVWFVW3S$EVhFSETFuHE|lF}3@Ct~z3F9Fu5#90~, 88tSShPjFSEC8j\W?YYttjhlFP#lFtlF3_^[UQQS]3VWU@;u!;r+;+s.t
Bu;r+3ҋ֋;3ҹEU+؉][
BJBBBBBBBB	B
BBB
BuU3ҋ]Nj3m>UEBBBBBBBBB	B
BBB
BBrt
Bu3ҋNj3_^[]UQS3W9E|9EsjVPPuEuϋ3uȁ;+º;r+;r+ʾ;r+^;r+_[]UEVRP`YY^]UuuMYY]ø mFUu3]]UQSVuӅtt33 mFBuW E3ÉUȋ} qF3 uF3 mF3 yF3ȋ qF3 uF3 mF3 yF3_ȋ qF3 uF3 mF3 yF3Wȋ qF3 uF3 mF3 yF3_ȋ qF3 uF3 mF3 yF3Wȋ qF3 uF 3 mF3 yF3_ȋ qF3 uF3 mF3 yF3W‰}ȋ qF3 uF3 mF‹3 yFm,rH3Ãȋ qF3 uF3 mF3 yFكu_t33 mFBu^[]USV#ދ؋#uWtt33 }FBuz E3_ȋ F3 F3 F3 }F3Wȋ F3 F3 F3 }F3_ȋ F3 F3 F3 }F3Wȋ F3 F3 F3 }F3_ȋ F3 F3 F3 }F3Wȋ F3 F3 F 3 }F3_ ȋ F3 F3 F3 }F3ȋ F3 F3 F3 }Fm9rH3ȋ F3 F3 F3 }Fكut33 }FGuӺË##_^[]3tt3uUQSVWE +7mvu_^[]UF3ʼnES]VW}3Dž| 3A@|@ ||h|W|FÃt֍t6|Ãt֍|u3M_^3[%]UEVRPYY^]UuuYY]UHSVW]K;COslj}ENC+ڋQ8ƉEދA(EЋA,EA0EA4E̋ALE܋APE3@]Yqt7yf8f<3*"~< w3^<@H#EF8jX_^[]AL FAT	AP FAXUQ‹SVWr33ۉEG9^4u#N$WPr(R F4uE9^(uN$~(^0^,~(];rW+Pv4f0F(O+~0;v+WPF4F0Pj+tES+Pv4T^0~0N(9N0uf0F,;sljF,3_^[]U
tjX_^[]Ã>
u3SAY;FtjES^Yt
jF3빅tAt@t
P b03jXUQQSVW3]39}v=ڃs3Ɂ;uFt3jX+ƋG;}rȋ]lj3_^[]UQSVW_u
{<sjjX9tES<3ʉc8+щS<rK8C8D5FK8sStVYtWjW6&9>tV^Yt6YPNPWh@uVuWjYYE=MEQPsYYËeuu[}u2EEPYjX:PPjh@\UF3E]UFj Y+ȋE3F]UEM]UEVH<AQAk(;tM;Jr
BB;r(;u3^]ËUEu2]ùMZf9uH<ȁ9PEuf9A]du2dVFP;t3u2^ð^KtrPbYt2jY|u2	ur	cUu}uuMPuUuu`YY]thFYwJj}	Y'U}uFu2]	u
jY]UVutu|7t*u&hFKYt2WhF8YDFuWFj Y+ȃ3FEEEFEEuE_^]jvjhFeMZf9@u]<@@PEuLf9@u>E@+PQgYYt'x$|!EE3Ɂ8ËeE2U&t}u	3F]U=Ft}uuuo
YY]UF3FuȃuhFYY#E]UF3Fȃu]kuhFYY]UuYH]UeeFVWN@;t
t	УFfEPEE3EEE1EE1EEPEME3M3M3;uO@u
Gȉ
Fщ
F_^]33@3ø@33hFEhF
Yðhhjuj8讑HH覑HH39FøhFødFU$SVj\tM)3hVP5F|xffftfpflfhEEDž@jPEVP
EE@EEEVXۍEEۉE|EEPxEu
!F^[]UDjDEjP 
EPEEtEj
X]3jEȅu2øMZf9uA<8PEuf9HuۃxtvՃh@|EUE8csmu%xu@= t=!t="t
=@t3]
̃%FSVtFtF;sW>t	8׃;r_^[SV|F|F;sW>t	
׃;r_^[%вEh`@d5D$l$l$+SVWF1E3PeuEEEEdËMd
Y__^[]QU%F(S3C	Fj
me3
F3VWF}S[wOWE؋MEineIE5ntelȋEj5GenuXjYS[wOWuCE%?=t#=`t=pt=Pt=`t=pu= F= F= F}EEEEE|2jX3S[]؉sKSEܩEEt	= F_^tm
FFtUtN3ЉEUEM3Ƀu3u/FFE Ft FF3[]39`FË
вE3@̃=Fr_D$fnpۋT$#+o
fftftff#uf~3:E3D$ST$t
:tYtQuWV؋
~333ƃu!%t%uu^_[3ÍB[ËB:t6t:t't:tt:tt^_B[ÍB^_[ÍB^_[ÍB^_[UW=F}wwUfnp۹#σ+3offtftf#uf#DžEЃSf#3+#I#[DžD_Ut93t;DDžt Gufnƒf:cG@LBu_ø#fft#Ϻf#ufft@ft뽋}3كE8t3_UVuW}t
N38sFN38_^]`USVuWEE^F3FPSE]}WE@fEE}~FGGLEteVMxf~UE8csmu7=lFt.hlFt5lFjua֋uEЋ9~tlXMt]s]E$t,]~t!hFFPuSE_^[]hFFP^^SukMӋI@j
Bu2u~CjYU}uPjU
Y]&U]*'Uu&Y]Uu&Y]UUME]UUME]UM33]UE]UE]V6v&&Y^V6f&&Y^ø-@ø2@Ã9Ã9Uu;&Y]Uue&Y]!ËËÃ9Ã9V6&&Y^V6%&Y^UEM;u3]Ã:utP:Quu]UuEtV0P%Yu^]UEŝH3iГAu]U33S]Vh(h-@h2@PKEQP]htz΍QAu+t| u
DuAEWP/%Yt7'GVu}PE%M3uu3uEEWE$Y_V$EY^[]̋L$D$׋|$<i % Fs	D$%Ffnfp+ρ~L$$ffGfG fG0fG@fGPfG`fGpu%Fs>fnfp rG   stb|9GD$tGutt $GuD$SVWT$D$L$URPQQh@d5F3ĉD$d%D$0XL$,3pt;T$4t;v.4v\H{uhChChd_^[ËL$At3D$H3Uhppp>]D$T$Ut$L$)qqq(	]UVWS33333[_^]Ëjg33333USVWjRh2@Q_^[]Ul$RQt$]Uu!Y]UE]VHE^V6!&Y^1XEÃ9Ë!ËÃ9V6t!&Y^Uu5 FYY]UEt=$FtP=!Y]U Ft'VuuPo FYjPYYV^]	R"Ã= Fu3SWHE5 F%YtuYj5 FFYYu3BVj(jF"YYtV5 FYYu3S5 F
YY3Vp Y^WXE_[hג@6 FYu2h$FPYYuá FtP7
 FYVWLF3jhWtdFr۰2_^UkELFPE]V5dFt kW4FWE
dFu_^UkELFPE]áFj Y+33FUF3E]UFj Y+ȋE3F]UUME]UUME]UEM]UEM]UEM]UM33]UM33]UQE]ÃhEhEhEjhEhEhEjh(Eh$Eh(Ejht>t6E&xFu^]áFj Y+33FUFj Y+ȋE3F]áFj Y+33FFÃ!USVW}&Ff9t~3ҋ:EtK<_t<<$t8<t0<-t,E]UVuuIN^]UVuuIN^]UVuuIN^]UVuuIN!^]UVuuIN`^]UV~0M9uAP9>uAF	16^]UV~=S]t4>uS'jjF$.t EX3P[^]UV~RW}tIS39uW9Gt<tP#SjF-t
WS[_^]USـ{NW}tE?t@V393uW0VjFi-t?tF<>uVWV"^_[]UV~->EttttPQYPPn^]UV>	t8W}?t.jjF,Ѕt
OJ3҅tT_^]Uyt
E@<~A]UEEA3AAA]Wt.GGt$VGwwGB֋GGYu^_U졼FШEEu]UVW}t.jjF,tH`EHx3uF_^]U`e3SWEEG}33@9tGEuMuMjEuWPuuEOHrVu3%=E‰Ut%%t%=WÅt%%t%=/=$@t^
F
Ft.EPYPEPj MVEEЋEEEPYPMU3ɋþt%#ƅ}QEPYYEPEPj{EPPMEPSIY5Fu>EPEPj,M/EMEEhEE4EPM0hEMEPY
FШEPEPj M5EMEEj EEMEEEEPM}M!Eu!E#!E!EċÉuMMȉMMt%#ƅtw%=u>EjPE܉EEEEjPE܉EEEEjPt'%=uEjPYYE܉EȋEE̍EjPE܋UYEEYEt@%=t2F`<`EPtCY@MEyCYPMj
FШt0t&EPEPEPY@MЉEEPYPM39t>9Mt.5Fu&WEPj MaEPM3EЋGEԋ}M}QtNEP3YYPEPhEMEPM5FP3MÅtI%GjF'ȉMt3Aa3ΉuQEPA3YY0xu%%=uzEPEPh EMadEMEEj,E;EMEEEEPEMEEj,E
EMEEEEP.tN%=u@EPEPh0EMEMEEj,EEPM`
htfF>hS]t[9}tVE+tIFWtjt
uSK>jt
 EHlju
FF[_^]FЃáFЃË
F3``áFЃáF% áFЃUSVu3C&Ff~FW@Zt3j,FɃ0	w @FEQ
FPPb^eeEPEP.$F+YY~
F9	t	EPEPF;uf&FF~4	jA_^[]U졬FXIEPUYufFt[@tPZtMj@FFШEuEPEPMU
H‰JJ@FEMP7@FFШEuEP@FhEMRE]U졬F08VN	y3uEj]PEMEe%W}EGthEME<\NtUF8tKEjPTYYPEPj[M>EMEEj]EEPMB}~?trGtEPEPuM@MWEPj(MUEMEEj)E,EMEEEEPEEEEEPEP!EUYYMP_E8t`PEPj(MXEMEEhEE]EMEEjEEMEEj]E|E$Ej]PE؍MjPj[PuEYY^]UjEYPM2
FtMA
F0t/Htu=MjjM:UFШt5<uKEPEPEPYPMU<uEPYPMcUt(EPEPhEME̋UЉEUt(EPEPhEME̋UЉEUEt"EMhEEԉUEԋU؉EUEt"EMhEEԉUEԋU؉EUu39t]~uBE9t;PEPj MsEԍM̉E̋Ej EVEPM6Ft
VE/VE9t%PEPj MEPM5U׀}t EMPEM}unu>t[FuBE8t:PEPjM_(EčM̉E̋Ej EVuM%VjuE8tPjME_^[]U3ɸ!E!EEQPhZFEMPuME]UMu4F?tIXtEPuYY@}FuMhEEEEEhEhEhEMe!]tEEEEEPYEPMEMMHI
FMhqEE^[]UuOEY]UFeeЃ$s@h$Eh,Eh4EhM]uFUMU8$Mu@F!MMj^UUMFUM8t@FjMMUE@HjE@E$9]tjME\EMj>kF59]u)M8&u@EF8*u`EFBFEX`_^[]UFVjj@t&Ff3VuCEPEMEEEj uEPMHEN^]U
F8uujuYE<6|<9~<_tMjS؃6A
F)u/t؃=A
F| ujux~uMj-E]eeVuWEFE9@EPEPh(EMEEEEF8tCEPLYPEPj MtEMEEEEPEEE"EPEPjMo8EEE
FEA
F<@FA`
F<`EPtmY@MEFШEPtwqYPEPj M1EMEEEEP?EEEEDYPMjEPuMjWYPMFШt&EPEPEPnY@MEEPPYPM39t;EPEPj(MbEMEEj)EEEEESjFt^fEVP!EPQMPEPj(mEMEEj)EDEPM
F`<`ttEPM
FEPtYPMYPMFШEPtYPMYPMStEEFEM؉M܉H
jME_^[]UjuEYY]W9u2_ËVp蘵^_Ãy$ ÊAËI2SVW{p_քu{pH_^[ËQtAD2UEjPnYYPEPj`MXj'uME]UVu}WtV7ѴYcuj^GS;sE;w8jhFt 3tOtG+މG_	3+ƉGGG[_^]
Fu3<0|<9/A
F3 tu
j Mj>MEt5F8uEMMy]F5FWEWP PMU5Ft+~1u%EPEPj~MXMUMUtEPMUMEPN5FjMHEB)Z_F5FOD9ft@t/6~8F4EMF4E FM4EoUM2?t9@,BSCjhEEPjUF5F0WhXEƃTSPFM4E?FujuM70pg4t
j M
Fh4EAEF

FEEPEPuaNA<$t/Mj0u
FQ}+tmAtSt7u!UEWPhZFE}AVP
FmPujVuA
FVuA
FVRt_tNtHuA
FA
F98tPhdEuSMhtEGA
FhXEM)9>t
j M
FhhEujubE_^]U졬F}tPXu3@FE8uMhE5PhPEu_u8HuxZuF8Yuu@uFYYvVuEVP-F@YYt$EPEPhEMMUF tEPEPhEыUME^Puju^E]UQQFVW<6|<9~<_uPuMAE3}90t97t	Gu	PM97t	WMEPutYYEuEjuVuP3>*PEPub jMuMd}397t	WMZS]93t97t
j MSM;EM[MH_^]UuuuuE]UQQFVW_@F8A@Fw|F3ҋMЉUMt}hEMjYPMtKF#ƃtu)hEhEMe#thEMRċMjԾE+j)MMUEHE @`_^]U졬Fu8@uM@F
uYYE]USVuWE&FF%FI]F7<@/=Ft
=Fx>tUVEPh(E|辽}EĉEȉFt(VEPj[tEEFEF8?@F$ZYHtVlPdP-Y>3F}]jEjPM؃uAt6EԉMMh(EEEMEEEEPq}]}ԋ3]}uRF8@uEPEPj[\}EM܉E܋Ej]ETE܉EFF~f&FkFTVPj]LPjDjP/EFH9_uMx?uGV<
FPj4jPȋAFF8@G,PYPEPj`$}EM̉E̋Ej'ETVPMvj@hFMVEPhXE,/EEF
F9	tFEPS;
FVPEEVPEjjPzȋAF~Ft<@tPf&F@>ujF0VEPh(EEPjM貺t@F_^[]USVu3WS^F#lj%FEjPȃAFFuBt<@t>VEPh(EEPEPYTȋAFF@u@FXtF#lj%FF?9ujK0VEPh(EEPjM跹yHN_^[]UQQFuMj|0j?u@FEPPj-u轾
uYYE]Uu3EY]UW9uEVupu^_]USVuW;t6uVFxWt}GPVt_^[]UyujhlEuu:E]UE;EsI@]UIt]2E]USVWu{upA;Es{uPr%_^[]Uqquu]UMu賷
FA
F<@unA
F<_uaEAjP
F
EjPFt,@t@Fu8tM@FEMHHFjjMbE]UEU+‹M;~ȅtSVW}+ي7Fu_^[
]U졬F8?u'@8$ujuYY"jjuFjjuE
E]U|F3ʼnESW}'Gg=FVV5F}A<@9e2e2ȃ0	w)Q
FEFP5F	ȋEAEu<$u"8FuF$tE1t0t6t$t,u
j M賶j>M詶}tF8t@FMEFE=F5F_M^H[
Mj襯E]Ue!E!EEejPhZFEPuFE]U졬FtLZuM@FE HVEPYPEPhEMޮj)uM!j)uEjPhEM赮@ӴE]UQFSVWj3ۿ@^:_u	BωF 7h/p'x<9uBF
3Ʉ_^[]ÍIK@R@Y@]@i@a@p@x@@U졬FtAMtj@hEFF
MjtE]Uuu]EYY]UQQMVuhEAΉF課EPYP蠱j}ڱ
F9@uA
F^]UM SVu3CAȉF:8F8EPEYEMEj EnVEPMtȋAF:F8@hEF8^tj@teEPYPEPj`M葩
EMEEj'EEP薰F8@u@F8^/8@thE{8^8uS蹱j}蚰F8@u,@F$: VEPSM蹩肯MMN^[]U<F3ʼnESV5FW}Ã0	w
FFPW5Fee?uLEjPNYY@M
FEA
F<@I3
F8M@P耬j,EjPVEu@Ej
PVEz
Eԉ5FP F@Y=Ft}jEPMEPj5FYPwYMtP讫hPE蟫EPEPuM

E̍M܉E܋EhTEE薯EChPEMZEPEPuMŧȭE̍MԉEԋEhTEEQEPMM:}t@uEȃe%F5Fj@hFM @ME}t
F9	t	EP萯EEGM_^3[蔄]áF%@ËAËA3939	ËAËA
ËA39t
At@39t
At@ËA3yW9u3_ËV0Ő^_ËA3@ËI3UQEx}4SXVWx0腐֋2tEx_^[@]ËAUFua3FAF
F3ңFPEFFFFFFFFFEw
kF]øF]ÁIÁI@ÁIÁI Ã9tIÁIÁIAUUtMVu+Au^]UM38t@A9u]UEu]ËMUStt:uBA	+[]jdhF+}u3k3uV؜Yu=FEF5F5F5FEPVuuuMUM讨}FJE
3}V諜YjdhF薎}u3k3uVCYu=FEF5F5F5Fu uuuuMM}F赬E
a3}VYUuuuuu&p0+y]UEPjuuu]USVWUjjh@u
m]_^[]ËL$At2D$H3袀UhP(RP$R]D$T$SVWD$UPjh@d5F3PD$dD$(Xpt:|$,t;t$,v-4vL$H|uhDID_뷋L$d
_^[3d
y@uQR9QuSQ0FSQ0FL$KCkUQPXY]Y[UF3E]UUME]UEM]UM33]3ɺF3

F3FVt	Uu/иFYFȃ3]̋L$W|$VStt9u~Ѓ3ƒtGt!ttuσ
t$u	u\"t=t)uu8˃ttu[^D$_ÈD$[^_ÉtȺ~Ѓ3‹t܄t΄t*tuĉD$[^_f3ҋD$W[^_fD$[^_ËUVuuO5j^0$huu^u	#53^]ËUVuu5j^0ɿ$huuu	43^]jhF3uu4t3s3}t38tӀ>u
4эEP3Y}u
e4봃eeuuWVuE轉Ëuu	u>YuYjh FP3uu3賾3s3}t33f9tf9u
3΍EPoY9]u
3벉]]uuWVuEËuu	u}YuYËUE0E0E0E0]ËUE0E0E0E0w]Ë1Y39ËU]Uj@uu]ËUVuu2j^0脽$huuu	203^]ËU]qUj@uu]ËUVuuZ2j^0$huuku	0203^]ËUuY]UE]UE]V6̴&Y^ËË!ËV6豴&Y^áFVj^u;}ƣFjP$jFx=Fu+jV5FjFR=Fu^W3@FjhF PRF4ǃ?k0FDt	tuF8GFu_3^ËUkE8@F]ËVW3F44FY PEu5F葳%FY^ËUMu0QjX]ËUtAEtUtA3]ËUE PE]ËUE PE]ËUE]ËUE]Ë@Ë@
Ë@ËUVuu/謺QFW
t9V7V"VpPy~t
vfYV谻Y_^]jh@FƄuu3uf/&;FVtgYeYeV1YuE覄ËuuYËUuY]jh`F4ej_YeuuuYYuEEËujrYjhFejYeuuYYuEËuj$YËU=Fu=Fu]Vuu1.EuVZYYt)jP!YYu9Fu3uVYYujİY^]ËU=Fu=Fu]Vuu-pEuVYYt)jPYYu9Fu3uVYYujCY^]ËUVW3WWjuWWhEu5-*39}tWWjuWWhEt_^]ËUVW3WWWWjuWWرEu,*39}tWWWWjuWWرEt_^]ËUQQSVW}tzVuVWE;r,G3;sjPEYYtwuuVE@=WPCP`}j=W蒃YYtȾ+;}@VPnYY;wύQAu+jYSoYYu3WSV蝯j豮Y_^[]ËUS]VWVu&VS}E;r+C3;sjPE3YYuuVMj=XSfNE@PAFPcz]j=SgYYt,+˃vVPwYY;]3Qff;u+jAPEFYYu
SuVW臭Y_^[]ËUE0E0YY]ËUE0E0YY]ËUSVW3PPjuPPhE]j*^u>*30t3PPjSPPhEtjW蜮YYt"WVjujjhEȅu)*2VʬY_^[]Åtj=Z+NWPjSjjfPhEt‹3VPYY븋USVW3PPPPjuPPرE]j*^uw)30t3PPPPjSPPرEtjWӭYYt$3PPWVjuPPرEȅu()*2VY_^[]Åt3ҍ1RR+@=WPjSRRرEtË3VPYY빋UEPE0-YY]ËUEfPE0geYY]ËUE0E0E0O]ËUE0E0E01]ËUE0E0E0]ËUE0E0E0j]ËUEP@u+]ËUEPffu+]ËUE0E0@YY]ËUE0E0OYY]ËUE0E0YY]ËUE0E0YY]ËUE]V6\&Y^39ËU3PPjuPuhE]ËU3PPPPjuPuرE]ËUuujujuhE]ËU3PPuujuPuرE]Ë!Ë!Ë33939F39FËV6蝩&Y^ËËËUjuYY]ËU}u&IjX]uuxYYu]a&]ËUjuYY]ËU}u:&jX]uuwYYu]&]ËU]0UWMGt
GAFuFGFGDVWRwHL
HHP+V7PP^u
PG_]yt	PÍAjYËUSVWuMJE33MzBuL+׍yAu+σMFrЍC]P Ytq3ۋEM:AF4+PV袨ul΍QAuE+MA:Ft+PVou9΍QAu+Crjg}Yt
M胡P_^[]3PPPPPTjYËUSVWuM9E3j_hENЍQAu+ʋBEBu+U
؃uύCPYt{eE:FpЋ+@PV莧uw΍QAuE+:F0+@PV`uI΍QAuE+MAEMrjH}Yt
M胡P_^[]3PPPPP5fUjuuuuu]ËUSVuME3ۋHEMtut9]t9]u"蘭SSjuSQhEEuHEPp"YWP趥YuWjuSuhEuHEP3"^6P}YtHuuuWuVEt+SSuujVSuرEuHEP!Y]VYWY_}t
M胡P^[]Ë
F3ËU}u]uuuuu豬̋Uujuuuu]ËUjjuuuug]ËUVuuuuuO^]UVuuuuu,FX\

`^]UEV0E0E0Ep0uKP^]UVuuuuuO^]UVuuuuu,FX\

`^]UEV0E0E0Ep0uxKP^]UVuuuuuO^]UVuuuuu,FX\

`^]UEV0E0E0Ep0uJP^]UVuuuuuO^]UVuuuuu,FX\

`^]UEV0E0E0Ep0utJP^]jh F7teE0YeMOuE
JtuE0bYjh@FseE02YeMQuE
suE0YjhFseE0YeMRuE
suE0YjhFDseE0YeMMuE
WsuE0oYjhFreE0?YeMIOuE
suE0YjhFreE0YeMOuE
ruE0YËUEMEEEPuEP]ËUEMEEEPuEP]ËUEMEEEPuEP]ËUEMEEEPuEP]ËUEMEEEPuEP]ËUEMEEEPuEP]ËU}uЦ2}tEEEEEEEEEEEPuYY]ËU}uw2}tEEEEEEEEEEEPudYY]ËU}u^2}tEEEEEEEEEEEPu3YY]ËU}uť2}tEEEEEEEEEEEPuRYY]ËU}ul2}tEEEEEEEEEEEPuYY]ËU}uS2}tEEEEEEEEEEEPuPYY]ËUQ}u輤SVuW}uu9u3]u$u u;v-GPVuuuM8"ulzcSVuEucDuuM8"u5CM)y(u+"ޣ_^[]ËUQ}u踣SVuW}uu9u3]u$u u;v-GPVuuuO8"upvgSVuEu3ɃfL^uuG8"u7=M+y*3fu#"֢_^[]ËUF3ʼnE}ES]u蔢ttVWu|M33ҫ‰u
uƅu PuuQPsC`tKE3Ƀtuuo;u*x);v%[tMty
;tMnFt
|P_^M3[_]ÅuË;uj^L밋UF3ʼnE}ES]uXttVWu|*M33ҫ‰u
uƅu PuuQP)CftQEtuuv;u.x0;v,btSty3f;tP3fGDt
|P_^M3[]]ÅuË;uj^3fD_뭋U
F3ʼnEES]VuHu葟OttWuM833ҫH4‰8<@u
DuƅD8 (LE H,E$HP,0P0P P(PLX^tKE3Ƀtuuo@;u*x);v%[4tMty
@;tM,C_t
PƋM^3[[]ÅuË@;uj^L밋U
F3ʼnEES]VuHuԝUttWuM833ҫH4‰8<@u
DuƅD8 (LE H,E$HP,0P0P P(P8LX`dtQEtuuv@;u.x0;v,b4tSty3f@;tP3fGiA_t
PƋM^3[Z]ÅuË@;uj^3fD_뭋UF3ʼnE}ES]uPttVWu|"M33ҫ‰u
uƅu PuuQPS=\tKE3Ƀtuuo;u*x);v%[tMty
;tM?t
|P_^M3[X]ÅuË;uj^L밋UF3ʼnE}ES]u蔚ttVWu|M33ҫ‰u
uƅu PuuQP	=btQEtuuv;u.x0;v,btSty3f;tP3fGh>t
|P_^M3[W]ÅuË;uj^3fD_뭋U}ul,]Vut:}v4u uuuVuu5yu ""՘^]ËU}u
贘]Vut<}v6u uuuVuu9y3fu 
"
[^]ÃuËËuËuËUQ3VuWs7
2SS39uv;w1V%EYtEP<EPÏY[_^]U샹\uAIAMQU
x9d}4Xuq,A1PdjP ҋld$2]U샹\uAIAMQU
x9d}4Xuq,A1PdjP ҋl襖2]U샹\uAIAMQU
x9d}4Xuq,A2PdjPZ ҋlf&2]U샹\uAIAMQU
x9d}4Xuq,A2PdjP( ҋl
觕2]UAAM@Q]UAAM@Q]UAAM@Q]UAAM@Q]U샹\uAIAMQU
x9d}4Xuq,A1PdjPJ ҋl	謔2]U샹\uAIAMQU
x9d}4Xuq,A1PdjP ҋlm	-2]U샹\uAIAMQU
x9d}4Xuq,A2PdjP ҋl讓2]U샹\uAIAMQU
x9d}4Xuq,A2PdjP ҋlo/2]UAAM@Q]UAAM@Q]UAAM@Q]UAAM@Q]U샹\uAIAMQU
x9d}4Xuq,A1PdjP ҋlt42]U샹\uAIAMQU
x9d}4Xuq,A1PdjP ҋl赑2]U샹\uAIAMQU
x9d}4Xuq,A2PdjPj ҋlv62]U샹\uAIAMQU
x9d}4Xuq,A2PdjP8 ҋl跐2]UAAM@Q]UAAM@Q]UAAM@Q]UAAM@Q]U샹\uAIQMY
x=d}8Xuq,A1PdjP_$ҋlE轏2]U샹\uAIQMY
x=d}8Xuq,A1PdjP,$ҋlE?2]UAAHE]UAAHE]U샹\uAIAMQU
x9d}4Xuq,A1PdjP* ҋl茎2]U샹\uAIAMQU
x9d}4Xuq,A1PdjP ҋlM
2]U샹\uAIAMQU
x9d}4Xuq,A2PdjP ҋl莍2]U샹\uAIAMQU
x9d}4Xuq,A2PdjP ҋlO2]UAAM@Q]UAAM@Q]UAAM@Q]UAAM@Q]U샹\uAA@MQT
x8d}3Xuq,A1PdjPҋlV2]U샹\uAA@MQT
x8d}3Xuq,A1PdjPҋl虋2]U샹\uAA@MQT
x8d}3Xuq,A2PdjPOҋl\2]U샹\uAA@MQT
x8d}3Xuq,A2PdjPҋl蟊2]UAAM@Q]UAAM@Q]UAAM@Q]UAAM@Q]U샹\uAIUIb
]
xAd}YYM_3^)]1VYËU
F3ʼnEVW8WI FY$0sNHFD(@F<4AL8DP@P8uu.:u*uSw7vuw7 :23:_^[]UQQS]VuWNpMƀp„3stESuEstSuctЀCuctCu}urukQSEYYMu
uu3;Mt:uh3Ƀ~	3}	;uRvSuS+YCY>8uu.:u*uSw7vuw7 :23:_^[]UQQS]VuWjpX~f;Mf;W?SE6WESEMut8MMulWuYYu
u|3;M{:uo3Ƀ~	3}	;uYvRuR+YCYE:Mu5M:u.uESp0v؋EWp0 :23:_^[]UQQS]VuWjpX~f;Mf;W8SE/WESEMut8MMulW)uYYu
u|3;M{:uo3Ƀ~	3}	;uYvQuQ+YCYE:Mu5M:u.uESp0v؋EWp0 :23:_^[]4Eø4Eø4Eø4Eø4Eø4Eø4Eø4Eø4Eø4Eø4Eø4EËUQSVMWj
Q~'FeHPMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FeHPWMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FeHPMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FeHPMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FeHPCMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FeHPMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FePMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FeP3MF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FePMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FePwMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FePMF8"tE;FrF2?ut_^[]UQSVMWj
Q~'FePMF8"tE;FrF2?ut_^[]VH讔u^S39^轹}D^8^F9^vF1PFtw$gxA~EN(^$^0^ ^,^<8'UI^(!?d-hFF1kFyFPP;F[^wAwAwAwAxAxAxAxAVH膓u^S39^u虸YCW*^8^F9^vF1PΉF輔F$yALD^$^0^ ~(^,^<4q'0H^(}.tDFF1VF赘t&U.F_[^蕷UBI'yA0yADyAMyAVyA[yAdyAmyAVH*u^S39^9A^8^F9^vF1PFtw$zAJEN(^$^0^ ^,^<8z'I|A|A|A|A|A|A}A
}AVHƎu^S39^虳Y>^8^F9^vF1PFtw$~AEN(^$^0^ ^,^<8'2D^(!M2hFF1kFPPJF[^ÍI}A~A~A!~A*~A/~A8~AA~AVH菍u^S39^}==^8^F9^vF2PFtw$A
EN(^$^0^ ^,^<8
'@C^(!3gFfF2fgFxAPP6F[^ÍIA A5A>AGALAUA^AVH_u^S39^uQ<Wz^8^F9^vF2PΉFcF$AD^$^0^ ~(^,^<4	'B^(4tHFfF2fRFht&)F_[^H;pAyAAAAAAAVHu^S39^:^8^F9^vF2PFtw$/A
EN(^$^0^ ^,^<8'A^(!5gFfF2fgFPPEF[^ËAAŁA΁AׁA܁AAAVHu^S39^ͮ9^8^F9^vF2PFtw$_A	EN(^$^0^ ^,^<8')@^(!]7gFfF2fgFAPP6F[^ÍIǂAЂAAAAAAAVHu^S39^u衭a8W^8^F9^vF2PΉF赌F$AD^$^0^ ~(^,^<4'>^(#8tHFfF2fRF8t&<)F_[^蘬X7 A)A=AFAOATA]AfAVH腇u^S39^=6^8^F9^vF2PFtw$߅AEN(^$^0^ ^,^<8'>^(!W9gFfF2fgFPPEF[^ËWA`AuA~AAAAAUE	A ]UE	A ]UE	A ]UE	A ]UE	A ]UE	A ]UE	A ]UE	A ]UE	A ]UE	A ]UE	A ]UE	A ]3@9Xu
9\t33@9Xu
9\t33@9Xu
9\t33@9Xu
9\t3ððððËXu\uÃu	\t2ËXu\uÃu	\t2ËXu\uÃu	\t2ËXu\uÃu	\t22222Ã\u3@9Xt3Ã\u3@9Xt3Ã\u3@9Xt3Ã\u3@9Xt32222Ãa(Ãa(Ãa(Ãa(Ãa(Ãa(Ãa(Ãa(Ãa(Ãa(Ãa(Ãa(A1 t-t"tHtuI I I 
I  I A1 t-t"tHtuI I I 
I  I A1 t-t"tHtuI I I 
I  I A1 t-t"tHtuI I I 
I  I A1 t-t"tHtuI I I 
I  I A1 t-t"tHtuI I I 
I  I A2 t-t"tHtuI I I 
I  I A2 t-t"tHtuI I I 
I  I A2 t-t"tHtuI I I 
I  I A2 t-t"tHtuI I I 
I  I A2 t-t"tHtuI I I 
I  I A2 t-t"tHtuI I I 
I  I uݥ02ðËVuu讥n02^ð^u荥M02ðun.02ðËVLuu?/2^ð^u/2ðu/2ðËVuuФ/2^ð^u诤o/2ðu萤P/2ðËVuua!/2^ð^u@/2ðËVju^ÍFPF1HP;^ËVju^ÍFPF1HP^ËVju^ÍFPF1HP^ËVj7u^ÍFPF1HP:^ËVjnu^ÍFPF1HP^ËVju^ÍFPF1HP^ÍQA<RQ2HR芈ÍQA<RQ2HRoÍQA<RQ2HRTÍQA<RQ2HR軈ÍQA<RQ2HR蠈ÍQA<RQ2HR腈ËVWFN1F<ыfTt-hA8hu@A,AA,A,
A,Q<3uz2uBA,
A<6uz4uBA,AuTt-hA8hu@A,AA,A,
A,Q<3uz2uBA,
A<6uz4uBA,AuTt-hA8hu@A,AA,A,
A,Q<3uz2uBA,
A<6uz4uBA,AuTt-hA8hu@A,AA,A,
A,Q<3uz2uBA,
A<6uz4uBA,AuTt-hA8hu@A,AA,A,
A,Q<3uz2uBA,
A<6uz4uBA,AuTt-hA8hu@A,AA,A,
A,Q<3uz2uBA,
A<6uz4uBA,Aut7ACt>D~GSuoV2SjWZttVHuQ=5ҋ|ɃpMt?g~1itntouS륋uM뜃N Qj
=댋J#냋TwsgHtЃgQi~0t(V 3WfEEt'tE-tE+tE N1xtXu	u2ۀat	At2ut'D=0Xt	At2$xD=^$+^8+uFPSHj PVvFPWEHPvN ~tuWSHj0Pjo?|F tWSHj P_^[]ËUQSV3C3F1dlX>t7ACt>D~GSuT2SjWZttVHuQ3ҋɃpMt?g~1itntourQ륋K뜃N Qj
8<댋u"냋RwsgHtЃgQit.~0uV 3WfEEt'tE-tE+tE N1xtXu	u2ۀat	At2ut'D=0Xt	At2$xD=^$+^8+uFPSHj PvFPWEHPtN ~tuWSHj0Pۮjn?|F tWSHj P谮_^[]ËUQSV3C3F1dlX>t7ACt>D~GSuR2SjWZttVHuQ$2ҋɃpMt?g~1itntouWO륋J뜃N Qj
|;댋!냋PwsgHtЃgQi~0t(V 3WfEEt'tE-tE+tE N1xtXu	u2ۀat	At2ut'D=0Xt	At2$xD=^$+^8+uFPSHj PvFPWEHPrN ~tuWSHj0P謬jl?|F tWSHj P聬_^[]ËUQSV3C3F1dlX>t7ACt>D~GSu9Q2SjWZttVHuQ0ҋ)ɃpMt?g~1itntouGM륋^H뜃N Qj
:댋 냋{NwsgHtЃgQi~0t(V 3WfEEt'tE-tE+tE N1xtXu	u2ۀat	At2ut'D=0Xt	At2$xD=^$+^8+uFPSHj PvFPWEHPyqN ~tuWSHj0Pڪjj?|F tWSHj P诪_^[]ËUQSV3C3F1dlX>t7ACt>D~GSu}O2SjWZttVHuQ.ҋ]ɃpMt?g~1itntou7K륋F뜃N Qj
9댋
 냋dLwsgHtЃgQi;t.~0uV 3WfEEt'tE-tE+tE N1xtXu	u2ۀat	At2ut'D=0Xt	At2$xD=^$+^8+uFPSHj PvFPWEHP?oN ~tuWSHj0P蠨jei?|F tWSHj Pu_^[]ËUQSV3C3F1dlX>t7ACt>D~GSuM2SjWZttVHuQl-ҋɃpMt?g~1itntouI륋E뜃N Qj
8댋I냋BJwsgHtЃgQi~0t(V 3WfEEt'tE-tE+tE N1xtXu	u2ۀat	At2ut'D=0Xt	At2$xD=^$+^8+uFPSHj P貦vFPWEHPmN ~tuWSHj0Pqjg?|F tWSHj PF_^[]ËUF3ʼnESV3jAZjXF2Ydk;>t6;Ct?D~GSuK2jjWZttVHuS+ыȃpMt?g~1itntouF뤋9C뛃N Sj
8닋f낋HvsfHtЃfSi8^0@V 3W‰]Af]j _t(t	j-XfEtj+tf}N2xtjXXf;u
t2atjA_f;t2j0_ut0jXXf|]f;tjAXf;t2$xffD]~$+~8+uFPWHj P.vFPSEHP0jN ^tuSWHj0Pj1f;|F tSWHj P£_M^3[L]ËUF3ʼnESV3jAZjXF2Ydk;>t6;Ct?D~GSu
J2jjWZttVHuS)ыȃpMt?g~1itntouD뤋PA뛃N Sj
6닋{낋EvsfHtЃfSi~I8^0@V 3W‰]Af]j _t(t	j-XfEtj+tf}N2xtjXXf;u
t2atjA_f;t2j0_ut0jXXf|]f;tjAXf;t2$xffD]~$+~8+uFPWHj P¡vFPSEHPgN ^tuSWHj0P聡jPd;|F tSWHj PV_M^3[]ËUF3ʼnESV3jAZjXF2Ydk;>t6;Ct?D~GSuH2jjWZttVHuS=(ыȃpMt?g~1itntousB뤋}?뛃N Sj
6닋낋CvsfHtЃfSi8^0@V 3W‰]Af]j _t(t	j-XfEtj+tf}N2xtjXXf;u
t2atjA_f;t2j0_ut0jXXf|]f;tjAXf;t2$xffD]~$+~8+uFPWHj PevFPSEHPgeN ^tuSWHj0P$j~b;|F tSWHj P_M^3[胿]ËUF3ʼnESV3jAZjXF2Ydk;>t6;Ct?D~GSu6F2jjWZttVHuSx&ы
ȃpMt?g~1itntou5@뤋=뛃N Sj
4닋낋?AvsfHtЃfSi8^0@V 3W‰]Af]j _t(t	j-XfEtj+tf}N2xtjXXf;u
t2atjA_f;t2j0_ut0jXXf|]f;tjAXf;t2$xffD]~$+~8+uFPWHj PevFPSEHP*dN ^tuSWHj0P$j`;|F tSWHj P_M^3[&]ËUF3ʼnESV3jAZjXF2Ydk;>t6;Ct?D~GSuMD2jjWZttVHuS$ыȃpMt?g~1itntou=뤋;뛃N Sj
3닋낋>vsfHtЃfSioI8^0@V 3W‰]Af]j _t(t	j-XfEtj+tf}N2xtjXXf;u
t2atjA_f;t2j0_ut0jXXf|]f;tjAXf;t2$xffD]~$+~8+uFPWHj PvFPSEHPaN ^tuSWHj0P踚j^;|F tSWHj P荚_M^3[躺]ËUF3ʼnESV3jAZjXF2Ydk;>t6;Ct?D~GSu_B2jjWZttVHuS"ы
ȃpMt?g~1itntou;뤋9뛃N Sj
2닋낋<vsfHtЃfSi8^0@V 3W‰]Af]j _t(t	j-XfEtj+tf}N2xtjXXf;u
t2atjA_f;t2j0_ut0jXXf|]f;tjAXf;t2$xffD]~$+~8+uFPWHj P蜘vFPSEHPa_N ^tuSWHj0P[j\;|F tSWHj P0_M^3[]]Ày1*t
A$P蛱ÃAA@A$yI Y$ËV~1*tF$PDZ^JDu^ËtF$y	N ؉F$^Ày1*t
A$PÃAA@A$yI Y$Ày1*t
A$PÃAA@A$yI Y$ËV~1*tF$PE^jDu^ËtF$y	N ؉F$^Ày1*t
A$PfÃAA@A$yI Y$fy2*t
A$P薲ÃAA@A$yI Y$ËVf~2*tF$Pò^Du^ËtF$y	N ؉F$^fy2*t
A$PÃAA@A$yI Y$fy2*t
A$PÃAA@A$yI Y$ËVf~2*tF$PD^Du^ËtF$y	N ؉F$^fy2*t
A$PfÃAA@A$yI Y$j	Xj	Xj	Xj	XjXjXjXjXøEøEøEøEøxEøxEøxEøxEËUEw$3AjX]3@]jj3]ËA A%AA)A)AAA-AAA)AjjMjj jj"jjA#jj$jj%jj5'jju(jj)jj)+jji,jj-ËSVWFFxt6_t/v,F1Pv6^4tF8F<F8F44EF8F<_^[ËUQeEVPqt`TtSSW}t6_t/v,F1Pv6裃^4tF8F<F8F44EF8F<_[^]ËSVWFFxt6_t/v,F1Pv6=^4tF8F<F8F44EF8F<_^[ËSVWFFxt6_t/v,F1Pv6ڂ^4tF8F<F8F44EF8F<_^[ËUQeEVP-qt`%tSSW}t6_t/v,F1Pv6^^4tF8F<F8F44EF8F<_[^]ËSVWFFxt6_t/v,F1Pv6^4tF8F<F8F44EF8F<_^[ËSVWFFxt6_t/v,F2Pv6Ձ^4tF8F<F8F44EF8F<_^[ËUQeEVPpt`tSSW}t6_t/v,F2Pv6Y^4tF8F<F8F44EF8F<_[^]ËSVWFFxt6_t/v,F2Pv6^4tF8F<F8F44EF8F<_^[ËSVWFFxt6_t/v,F2Pv6萀^4tF8F<F8F44EF8F<_^[ËUQeEVP;pt`ǽtSSW}t6_t/v,F2Pv6^4tF8F<F8F44EF8F<_[^]ËSVWFFxt6_t/v,F2Pv6^4tF8F<F8F44EF8F<_^[ËUQQVWN F(yF1#A{۠UMW~ t|s
كڃ@~ ~(_}	F(f 9F(~F(uf uuuRQlQ0gF t~8tF480tN4F40F8^[]USVv,uY؋˃txtVIt3tJU2F FFHPXF FFt@?H3;F FFt@!@F FFt@@W~ t|s
كڃ@~ ~(_}	F(f 9F(~F(uf uuuRQlQYfF t~8tF480tN4N40F8^[]USVv,+Y؋˃txtVIt3tKI2F FFHPXF FFt@?H3;F FFt@!@F FFt@@W~ t|s
كڃ@~ ~(_}	F(f 9F(~F(uf uuuRQCkQeF t~8tF480tN4N40F8^[]UQQSVv,e؃eY˃t^It:tG2&F EPt2F FFHPXF FFt@?H3;F FFt@!@F FFt@@W~ t|s
كڃ@~ ~(_}	F(f 9F(~F(uf uuuRQdQ@^F t~8tF480tN4N40F8^[]VWFFx8u'=2Dv,Yt+tHtu΋FWFfFfFF0_^ËUQeEVPEu2vti8u<Zv,FYt4t#HtuЋFMQENEfNfENF0^]ËVWFFx7u<2Dv,Yt+tHtu΋FWFfFfFF0_^ËVWFFx 7u;f2Dv,PYt+tHtu΋FWFfFfFF0_^ËUQeEVPDu2v讐ti6u;v,Yt4t#HtuЋFMQENEfNfENF0^]ËVWFFx6u:Y2Dv,CYt+tHtu΋FWFfFfFF0_^ËVWFFx5u%:2Dv,Yt+tHtu΋FWFfFfFF0_^ËUQeEVPCu2vCti5u9Xv,DYt4t#HtuЋFMQENEfNfENF0^]ËVWFFx4u92Dv,Yt+tHtu΋FWFfFfFF0_^ËVWFFx4u8d2Dv,NYt+tHtu΋FWFfFfFF0_^ËUQeEVP|Bu2v؍ti3u8v,Yt4t#HtuЋFMQENEfNfENF0^]ËVWFFx3u7W2Dv,AYt+tHtu΋FWFfFfFF0_^ËQ t	ʀQ jjËQ t	ʀQ jjËQ t	ʀQ jj ËQ t	ʀQ jjKËQ t	ʀQ jjvËQ t	ʀQ jjËQ t	ʀQ jjËQ t	ʀQ jj+ËQ t	ʀQ jjËQ t	ʀQ jjËQ t	ʀQ jjËQ t	ʀQ jj?jjA(A,
)jjA(A,
[jjA(A,
jjA(A,
jjA(A,
%jjA(A,
jjA(A,
jjA(A,
jjA(A,
UjjA(A,
jjA(A,
jjA(A,
ËSVWFF~(X^4uv,F1Pv6\LtuF4~4Ej$Yf9u)9Xuh@dWPi~dž\\\uQj
E}Pv>UHB
F9Xu#x(j$Xf9u d}
;ȉ
_^[]b2ðððÃytytv62ðÃytytT2ðÃytyt22ðÃytytЩ2ðËVnu2^Ã\uOXuF
td)FAtt
tuFF;uӰ^L뎋Vu2^Ã\uOXuF
td)FAtt
tuFF;uӰ^̨뎋Vu2^Ã\uOXuF
td)FAtt
tuFF;uӰ^L뎋VTu2^Ã\uOXuF
td)FAtt
tuFF;uӰ^̧뎰ðððÃ\uGXu>
x!d}q,A1PdjPq2ðÃ\uGXu>
x!d}q,A1PdjP^2ðÃ\uGXu>
x!d}q,A2PdjP˦2ðÃ\uGXu>
x!d}q,A2PdjPx2ðððððËUMVAujQ8оFYtt?k0Fƀx)u"ttƒ?k04FF-t-2^]ðø*uPj?fEG;}uԋM>ut_^[]UQQSً@txu
ME^EVuW}&GME;t4EPP/E8u>*uPj?E;}uҋM>ut_^[]UQQVW}E'Mp9puxt
MEJEE+pS];rVu0NM0pxEt;t0[M?ut_^]UQQS]WE#Mz9zuzt
MEQEL+zE;rV4?Vu2NM0^xxEtM;}t8M;ut_[]UEMH%]ËU,EUMEEEEEEMUEu
ʚ.tEEԍEE؍EE܍EEEEEPR3YY]ËU,EUMEEEEEEMUEuS.tEEԍEE؍EE܍EEEEEPRlYY]ËU,EUMEEEEEEMUEuܙ.tEEԍEE؍EE܍EEEEEPRYY]ËU,EUMEEEEEEMUEue.tEEԍEE؍EE܍EEEEEPRYY]ËU,EUMEEEEEEMUEu..tEEԍEE؍EE܍EEEEEPRYY]ËU,EUMEEEEEEMUEu
w.tEEԍEE؍EE܍EEEEEPRhYY]ËUu$u uuuuuuF ]ËUu$u uuuuuu# ]ËUu uuuuuu]ËUu uuuuuu]ËUu uuuuuuD]ËUu uuuuuu]ËUu uuuuuu5]ËUu uuuuuuP]̋UQF3ʼnEMS];vlEVW;w(IMWVвEU~E;vM;t!t+RLDJuEM+؍;w_^M3[ T]̋UEW};t&Vut+@TLPu^_]̋UF3ʼnEMUVuW}u$t $_^M3yS]Åt܅tDžJSщ3+XwVWQ}SQΉвEփ~WSвEփ~WSвEփ~WS;v7;s%SVвE~;w=;wSVвE׋~ۋ+;vSWвEփዕ;r^;t3ދ׋+ߊRLDJu답;މ;s2$+;v%SWвEt;r/+;vSWвE֋t݋Nj++;|9;s|@;sL΋j;sT@;s׋+xT[M_3^u]ËUQjuQQuuPu]ËUQjuQQuuPu]ËUQjuQQuuPuz]ËUQjuQQuuPjN]ËUQjuQQuuP^u!]ËUQjuQQuuP1ui]ËUQjuQQuuPu]ËUQjuQQuuPu]ËUQjuQQuuPj]ËUQjuQQuuPcj]ËUQjuQQuuP7jp]ËUQjuQQuuPj7]ËUQjuQQuuPj]ËUQjuQQuuPj]ËUQjuQQuuPjf]ËUQjuQQuuPvj]ËUQjuQQuuPJj]ËUQjuQQuuPjW]ËUQjuQQuuPj]ËUQjuQQuuPj]ËUQQeEjP^YYtEMt]ËU3W}jEPYY_tUEMtQ]ËUQQVuuj3S}ueEeSP`ME>jhޱPQa][|	=wkd3@N^]ËUQQVuuBj3W}ueEeSPME>jhޱPQ][|	=o@wkd3V@N^]ËUQQeEjPYYtEMt]ËU3W}jEP2YY_tUEMtQ]ËU]U]UV)tuV4YY#^]ËUVtuVYY#^]ËUVuu*j^0hWj	Y}uj^0h?|?~j^0\S3ۍEP]]]YwEPYeEP YS=~_=}X+EEEPV}YY9]VYE)EEPVKYYF WV.YY>9]tVYtEE+F +}j<[yJ<+Ǚ~ǙVyJ<+NǙj~Ǚ[VyJ+NǙȅ~Fj_NVN3[_^]yFNj_FV׃FFmFNSSSSS,g̋UVuuj^0fSWj	Y}uj^0f-S39_|9rjX9G|?o@vj^0[_^]E]P]]YEPYEPY_|vujX;n|{x|Ml}PuxuuP_Mt^t
hPM3_]ËU|W}uAY}tSVu3ۃuNff;u+uMu w}EME}PuEuuP^MKuЋPY]8]t
M䃡P^[_]ËUQQEEEPuEtYY]ËUQQEEEPuEsYY]ËUQQEEEPuE~YY]ËUQQEEEPuE[YY]ËUEPqY]ËUEjPYY]ËUuMuuuE\E]ËUuMuuuX\E]ËUuMuuuk\E]ËUuMuuu~\E]ËUF3ʼnEEVu,tuGW3@"QMQPVQP.2U$^t
MM u
M3e]ËUF3ʼnEEVu,tuV3@"QMQPVQP2U$^t
MM u
M3]ËUF3ʼnEEVu,tuQV3@"QMQPVQP81U$^t
MM u
M3o]ËUF3ʼnEEVu,tuU3@"QMQPVQP1U$^t
MM u
M3]ËUF3ʼnEEVu,tu[U3@"QMQP7VQPB0U$^t
MM u
M3y]ËUF3ʼnEEVu,tuT3@"QMQPVQP0U$^t
MM u
M3]ËUF3ʼnEEVu,tue%T3@"QMQPVQPL/U$^t
MM u
M3]ËUF3ʼnEEVu,tuS3@"QMQP-VQP/U$^t
MM u
M3]ËU$VuWоujXAFΉEFSE艒]MMMu܉MnSEjPuMU--t+u5ȈMIiNn3ۈ]0uCF΋~EE
fn4
3j0YE}f;uSw]ˋ蟍xtXtPfU3EsfЉ}܋fU}3u؋uMj0EXMf;uP^;ffUf;tuj0X3E:DžHDž``EjIEE	DžLf	@Ep	Džx	E	DžXf
Ep
Džp
E
DžDfEpDžhfEpDžPEEf
Ep
EPEZEEE E*E@EJEDž|DžtDžlDždDž\ADžTZEaEf;f;Usƒ0f;Hf;`f;Us
-`f;Uf;Us
-f;Lf;Us
-f	f;xf;Us
-	kf;Xcf;Us
-f
Kf;pCf;Us
-
+f;D#f;Us
-ff;hf;Us
-ff;Pf;Us
-f;Uf;Us
-f
f;Uf;Us
-Pf;Uf;Us
-wf;Urvf;Us
- af;Ur`f;Us
-@Kf;UrJf;|s
-2f;tr.f;ls%-f;ds
-u:f9\w	f;Tv
ff+Ef;Ewff+Ef;Ew ;w.M;tAMEl@fj0fUXE;5UfȋEuj0;fMXu*f;u%uN	fj0XfMf;tUuu䋽@f;f;Ms0f;Hf;`f;Ms
-`f;Mf;Ms
-f;Lf;Ms
-f	f;xf;Ms
-	kf;Xcf;Ms
-f
Kf;pCf;Ms
-
+f;D#f;Ms
-ff;hf;Ms
-ff;Pf;Ms
-f;Mf;Ms
-f
f;Mf;Ms
-Pf;Mf;Ms
-wf;Mrvf;Ms
- af;Mr`f;Ms
-@Kf;MrJf;|s
-2f;tr.f;ls%-f;ds
-u:f9\w	f;Tv
ff+Ef;Ewff+Ef;Ew ;w&;tBUM腆Ufj0fMXu&4P3Huu衰FΉE؋FE)fE3˃EtPt
et
puM8]Pfj-Xf;fMj+Zf;tf;uDžffMj03Xf;u諅fj0XfMf;t3f;f;Ms0f;Hf;`f;Ms
-`f;Mf;Ms
-f;Lf;Ms
-f	f;xf;Ms
-	kf;Xcf;Ms
-f
Kf;pCf;Ms
-
+f;D#f;Ms
-ff;hf;Ms
-ff;Pf;Ms
-f;Mf;Ms
-f
f;Mf;Ms
-Pf;Mf;Ms
-wf;Mrvf;Ms
- af;Mr`f;Ms
-@Kf;MrJf;|s
-2f;tr.f;ls%-f;ds
-u:f9\w	f;Tv
ff+Ef;Ewff+Ef;Ew 
s.k
ЉU;2Ufj0fMXEQj0Zf;f;Ms
+yHf;Z`f;`f;MrҋUf;Nf;MrLf;9f;Mrxf;$f;MrXf;f;Mrpf;f;MhDf;f;MOhf;f;M6Pf;f;MUf;f;MUf;f;MUf;rqf;MUf;r_f;MUf;rMf;MUf;r;f;|tf;r#f;lsf;du$f9\w	f;Tv*Uff+f;Ev
s-OffM*Uff+f;Ew ΄t]u4IKt`fE]u\uMV;tXyuI;u;tI;$;|'38EH@E؁P~j	j;}j3+8EN*jX%u܍EuWPu܍EuWP!^_[]ËU$VuW}ujXAFΉEFSEf]MMMu܉MKSEjP]uMU--t+uȈMIiNn3ۈ]0uCF΋~EE
fn4
3j0YE}f;uSw]ˋ}{xtXtPޥfU3EQ{fЉ}܋fU}3u؋uMj0EXMf;uP^{ffUf;tuj0X3E:DžHDž``EjIEE	DžLf	@Ep	Džx	E	DžXf
Ep
Džp
E
DžDfEpDžhfEpDžPEEf
Ep
EPEZEEE E*E@EJEDž|DžtDžlDždDž\ADžTZEaEf;f;Usƒ0f;Hf;`f;Us
-`f;Uf;Us
-f;Lf;Us
-f	f;xf;Us
-	kf;Xcf;Us
-f
Kf;pCf;Us
-
+f;D#f;Us
-ff;hf;Us
-ff;Pf;Us
-f;Uf;Us
-f
f;Uf;Us
-Pf;Uf;Us
-wf;Urvf;Us
- af;Ur`f;Us
-@Kf;UrJf;|s
-2f;tr.f;ls%-f;ds
-u:f9\w	f;Tv
ff+Ef;Ewff+Ef;Ew ;w.M;tAMEJw@fj0fUXE;wUfȋEuj0;fMXu*f;u%uNvfj0XfMf;tUuu䋽@f;f;Ms0f;Hf;`f;Ms
-`f;Mf;Ms
-f;Lf;Ms
-f	f;xf;Ms
-	kf;Xcf;Ms
-f
Kf;pCf;Ms
-
+f;D#f;Ms
-ff;hf;Ms
-ff;Pf;Ms
-f;Mf;Ms
-f
f;Mf;Ms
-Pf;Mf;Ms
-wf;Mrvf;Ms
- af;Mr`f;Ms
-@Kf;MrJf;|s
-2f;tr.f;ls%-f;ds
-u:f9\w	f;Tv
ff+Ef;Ewff+Ef;Ew ;w&;tBUMctUfj0fMXu&4$?3Huu蒞FΉE؋FEtfE3˃EtPt
et
puM8]Psfj-Xf;fMj+Zf;tf;usffMj03Xf;usfj0XfMf;t3f;f;Ms0f;Hf;`f;Ms
-`f;Mf;Ms
-f;Lf;Ms
-f	f;xf;Ms
-	kf;Xcf;Ms
-f
Kf;pCf;Ms
-
+f;D#f;Ms
-ff;hf;Ms
-ff;Pf;Ms
-f;Mf;Ms
-f
f;Mf;Ms
-Pf;Mf;Ms
-wf;Mrvf;Ms
- af;Mr`f;Ms
-@Kf;MrJf;|s
-2f;tr.f;ls%-f;ds
-u:f9\w	f;Tv
ff+Ef;Ewff+Ef;Ew 
s.k
ЉU;qUfj0fMXEQj0Zf;f;Ms
+yHf;Z`f;`f;MrҋUf;Nf;MrLf;9f;Mrxf;$f;MrXf;f;Mrpf;f;MhDf;f;MOhf;f;M6Pf;f;MUf;f;MUf;f;MUf;rqf;MUf;r_f;MUf;rMf;MUf;r;f;|tf;r#f;lsf;du$f9\w	f;Tv*Uff+f;Ev
s--offM*Uff+f;Ew ΄t]u49t`nfE]uMuMV;tXyuI;u;tI;$;|'38EH@E؁P~j	j;}j3+8EN*jX%u܍EuWPu܍EuWP[^_[]ËUS]EV3EW}Ɖ}]u:XEt:\EugVmȋE@EuQ蛗GωEGE+m:`Et:hEu-mFuP]jX_^[]ÍM8jM83ɄՋUS]EV3EW}Ɖ}]u:Et:EugmȋE@EuQ`GωEGEl:Et:Eu-lFuP"jX_^[]ÍM5jM53ɄՋUS]EV3EW}Ɖ}]uf;xEt	f;Eur
lfȋEfEuQSGωEGEkff;Et	f;Eu0kf
uPjX_^[]ÍMT7jMH73ɄՋUS]EV3EW}Ɖ}]uf;Et	f;EurkfȋEfEuQ
GωEGEkff;Et	f;Eu0`kf
uPŕjX_^[]ÍM~4jMr43ɄՋUSVuEW}3ۉ}uE:pEt:tEuJ;jCuP舔GωEGEj<(t)M%4M4jiWVYYtjWVYYtj[RH>)t@t1ȍAЃ	vAvAv	_ozi<)uɀ>)YjX_^[]ËUSVuEW}3ۉ}uE:Et:EuJiCuPGωEGExi<(t)M=3M#3jBiWVYYtjWVYYtj[R腓H>)t@t1ȍAЃ	vAvAv	_oh<)uɀ>)YjX_^[]ËUSVuEW}3ۉ}uEEf;Et	f;EuPFhfuP蘒GωEGE hff(t)M4Mi4jgWVfYYt	E
WVYYtRENj)[f9tCft2ȍAЃ	vAvAv	_gwgff;uf9OjX_^[]ËUSVuEW}3ۉ}uEEf;Et	f;EuPgfuPGωEGEggff(t)ME1M+1j.gWVf)YYt	E
WVYYtRuENj)[f9tCft2ȍAЃ	vAvAv	_gfff;uf9OjX_^[]ËUSV3W}:Et:EuMeFu޳_^[]ËUSV3W}:XEt:\EuMfFu޳_^[]ËUSV3W}f;8Et	f;@EuMefuس_^[]ËUSV3W}f;xEt	f;EuMefuس_^[]ËUSV3W}:Et:EuMdFu޳_^[]ËUSV3W}:HEt:PEuMeFu޳_^[]ËUSV3W}f; Et	f;,EuMdf
uس_^[]ËUSV3W}f;`Et	f;lEuMdf
uس_^[]ËUE	$DBuu YY]uuWE38E3]ËE38ދE38ŋE38묋E릋E 3@]ËE3j8EX]ËE3j8ݍItBBBB×BܗBBBB&BUE	$HBuu3YY]uujEuPYY3]ËEuPEuPЋEuP`uRuj4YY3@]ËEuPYYjX]ËEuP^YYjBBBBΘBBBBB-BU@MVWt!},t%|$~誗j"3ЋTSuMq3MEEEЋE Ea؍EPjQM|a؍EPjP]u8E0E-uE+u
M>a؈]Mtu{,0<	wÃ",a<wÃ,A<wÃt	uAj
_Y؍EPjP]Ku8E0E-uE+u
MY؈]Mtu{,0<	wÃ",a<wÃ,A<wÃt	uAj
_P`PhVacu3P\`PhVX33ۋ$C;Xu苝Pss	L73P\`PhV=;`us`0tЉX{牕Xu<33,0+@0,u;!0O,33ҋL49<st_;u0@lj,40,L04,@LF4;PYYju3 t@3su3 \t@3QЋ+;j#_3҃j Y+ȉ3@{HɉЉtA3j X+9ssut2rr	jrZʉ;+;rl;s3F;sB3##苍㋍ÉIN;t됋t3Zuډ<3PPhPb<+Љt+;v!jP+;w9r0K;t0;`uI;u;t;`wF3j Y+ʉ@3҉yHɉЉtA3j Y+ȍ9ssut2rr	jrZʉ;+;rl;s3F;sB3##苍㋍ÉIN;t됋t3tB2*3PPhP=:\PPsYYʉ‰u;wtp3tp3 ;vI+t%33@wƅ##tƅыËw3;@#0;3#4ƃHwȋtx+PWRQ-PPQ,PM_^3[6]ËUQQE3ɋUSV3W3r8HHIJEBȉM;t5MI;w#r;wMڃmF;uMU
tFt2E;uuuPuSW_^[]̋UMt	+]ø ]ËËUQV>u%jh cYYE΍EPu諽Y^]Àyt	ø3̋US]u3[]W}u
_33[]VpAu-OM؃u/sKPPhQF73^_[]ÅuIsjP{DžhW
73ҋu؃3;ʉ^3_[]3EE}tDEF@E4d$jQ3WPRqUv3҉]ЋMUmMMu΋]jDžPshVh6EU3;ȉ>CE^A_[];wG֍H+ЉMȋ;|2F+4<;u
I;}u+‹D;DsBu^_33[]Ë}ȋE4DEƉut	+  M+Eąt)EMMeũvuMċD	E3EU,KM:KEM;EwA3}Q	EEEMvI‹M3UMsMƋu}EurEEMċDEujuPRo]3؉u؋‰]E]Euv*jũPS
p3u؉]]EEwPrwIPS3ɋMjuMo;r)w;Ev"E]}̉EUEu
vE]uM33tUE]EME؋Ee؋ȋEe3;s+EmEu]M3;wGr9}s@t5uU؍$
v3RNˉJ؃u]UEHEu3UËMEmJ]H}UME3UB;sHI@;rt<uu֋^_[]ËAËA38AH%ËÃAQƒQVqt9qrw9Qw164YtF^2^ÃAQƒQVqt9qrw9Qw	f;u3^ÃAQƒQVqt9qrw9Qv2^Ë	}ȃ^"ÃAQƒQVqt9qrw9Qw	]f;u3^ËV63YtF^ËV62Yf;tF^ËыJ;JuAJËыJ;JuJÍQ V3+;#tAF;u^ËVr3 +;#t@F;u^ËUUu21Et'tuR<'BvՃ ]UUu21Et'tuRDv'BvՃ ]UUf;u23Et)tuRD\'
Bfvf ]UUf;u23Et)tuRL'
Bfvf ]UMAЃ	w]ÍAvAv_]ÊAËUkU3M8
E]339ËAËAËA(x~+~t
t	t
3q &q &Y38A$@ËA0x~+~t
t	t
3q(Q&q(j&Y38A,@ÊAfAÊA̋UE3ҋMHMɉHB]38AH38AH%38AH%ËA(ËA0̋UF3ʼnEMS]V WyuW0,PhC;PS3$3ɋ؋$ƃ$A;u拝 sst_^[M3xy]j0Dž,PhR-2_^[M3>y]Ë3{sPA(PhV-uW0,Ph;V
$(33ɋ$ljA;$u苝 ss|_^[M3x]j0Dž,PhV,2_^[M3Ex];Ct
$yA$3҉(3ۉ,0+$0u;S0,339stJ;uCDŽ0lj,$ƃ0GA,;ut9s;uADŽ0,30,AuǃstPC;( P0Phv+_^[M3v]Ë jDž@DPh1+M32_^[}v]̋UW}u+E,WQh8P(*_]ÃtMtSQ3VU3ȍ$ÃڋUF;uMt
ss\^[_]j,Dž(PhR\*2^[_]̋UEeȋEe]̋UF3ʼnEeSVHDW}X'&$&GىPE4E<1W,0jPӊPEEP0Pi,0u1\`XjPhGP,)BuX2Xu3P3ɍNj0$ƃXA;u݋Xsstj0Dž,PhR(2XwLP0PhVK(u#S0,PhV)(?6T&33ɋ$ljA;TuXss
|j0Dž,PhV'2;t@00L@3҉T3ۉ\`+8I`jj
jjjjj?2C'C/C9C?CECICOC+CTCVNtt2^Ë^^8VNtt2^Ë^^pVNtt2^Ë^P^騝VNtt2^Ë^鈟^UQQVuEEu Pv,Fv(PQTv`,}u2~&tjRPr^]UQQVuEEu Pv4Fv0PQTvh9,}u2~.tjRP^]UQQVuEEu Pv4Fv0PQ:TvHԋ,}u2~(tjRP^]UQQV>uEEu PvTt,hP:huA A^A @A A^@A A^Íp3ux2uAA 	^À6ux4uA 
A^Àdtitotut
xtXu\q@A A^Ãlt$ttzu;@A A^@A A^ÍP:luA A^A Q^ËAVjItVLtBTt.jh^;Pf92uA(A^A(A(A^ÃA(A^Íp3ufx2uAA(	^Ã6ufx4uA(
A^Ãdtitotut
xtXudq빃A(A^jl^;t(ttzu?A(A^ÃA(A^ÍPf92uA(A^A(Q^ËVVfPt6Fu&3F*FfFFFFF F$F(2	@NF^QPj][f;t2Hf;vˋCEf;tVFf;uuQFFUj]Yf9u]Ff8u
j2tF[_^]ÍA,ÍA4Ë3A#u3ɊË3A#u3ɊË3A#u3ɊË3A#u3ɊËUVu
yNF
^]UVuyNF^]A uA$t
tuA$ËA(uA,t
tuA,̋US]3Vþ ΉE+ˉ]WFM+IUHEЉEE:t@3M+;Í]sǃsut2ۄr;Buރt_+z@<E;rG
;s3ҍF;sG3#EKMN#UMM‹UMMuutz3}tF_2^[]jDžPBhP1
2_^[]ËUEF(tOjY3}jEP3@Puُt3FPEPY
YYxt't"u	2[HEPY3H#fF3@fFEFt3ۍESPSSSWEt
EFV3@M_^3[7]ËUPF3ʼnEESVuW}WE}E3@;fF3ۋEt M]QP
YYEHFj
Y3}j(EPSu貎EPuo	SSufFulF(#‰V,Rv(uuIF #‰V$tpv,v(uu(F0#‰V4tOjY3}jEP3@Put3FPEPYYxt't"u3	2[HEPY3H#fF3@fFEFt3ۍESPSSSWEt
EFV3@M_^3[-6]ËUPF3ʼnEESVuW}WE}E3@;fF3ۋEt M]QPbYYEHFj
Y3}j(EPSuEPuSSufFuF #‰V$Rv uuF#‰Vtpv$v uulF(#‰V,tOjY3}jEP3@Puat3FPEPYYtt't"uw	2WHEP+Y3H#fF3@fFEFt3ۍESPSSSWEtMN3@M_^3[u4]ËU(F3ʼnE}u}uEpEPEPEtNEPEPjEt:MEPEPEPEPEPEPEPu
HEP@YM33]ËU(F3ʼnE}u}uEUvEPEPEtREPEPjEt>MEPEPEPEPEPEPEPwȃ#ʃu
HEPYЋM3*3]ËUE 0EPEPEPEPEPEP!]ËUE 0EPEPEPEPEPEP[!]ËUE 0E0E0E0E0E0E0!]ËUE 0E0E0E0E0E0E0 ]ËUE]UEEA]UEEA]UEEA]UE]UE]UE]UEEA]UE]UE]UE]UE]UE]UE]V>t6t6"u
ɰ"FM5tGFEP(,YttGFEtMu< t<	utGNE>< t<	uF>Mt9ME3B3F@>\t>"u1uMtN9"uM3҄EHt\Gut;}u< t1<	t-t#tGPO+YtFtGFwtG5M_^[t!E]ËUEMUSVu3W}tuE E	j"Xf9u
Ãt	ffftuf;Et	f;Ej"Xuąt3fB]3Ef9f;Etf;Eu3f9tu3j\^E@f91tj"^f91j\^u8u 8]tj"^f9qj\^u
8]]E}
Htf2uft*8]uf;Etf;Et9]ttfsu]t3f3t_^[]ËUE0F]ËUE4F]ËUE]UE]UE]UE]V6X&Y^ËV6X&Y^Ë3ҋ9t	IB9uË3ҋ9t	IB9uË!Ë!Ë!"ËU]U]ËËËø Fø$Fá(Fá,FËV6X&Y^ËV6W&Y^ËUEPT(Y]2ËUVu?r3=WM3ҋu;s
M+;w31jP+YjW_^]ËU]U]UE0F]ËUE4F]áFu
FáFu
5FáFu%9Fu3Eu#FáFu%9Fu3ou#FÃ=Ft3VW`!(u*VYuPFFl3jsVYVlVY_^Ã=Ft3VW(u*V|YuPFFI3jVYVVY_^ËUVu3ҊtW<=tB΍yAu+Fu_^]ËUSVu3ۋft+Wf=tB΍yff;u+4Nfu_^[]ËUQQSVW}3ҋ<=tB΍YAu+FuBjPVYYtm]RύQAu+ʀ?=AEt7jPVYYt0WuVUuAEj0EUEY?uS#jTYY3jTY_^[]3PPPPP\̋UQQS]3EVWft/j=[f;tB΍yff;Eu+4Nfu׋]BjPV3YYty}]ˍQff;u+j=AYEf9t8jPUYYt2SuVzuCE03VE	TEYCf93uWX3VSYYVSY_^[]3PPPPP[̋UVutWPSYuVSY_^]ËUVutWPSYuVsSY_^]J%%W=Fu_SV3QSSSSj7SSرE؅tLjSTYYt5jjSVj73SSرEtSV9SS9u3^[_VRYW=Fu_SV3KSSj7SShE؅tHjSQTYYt1SVj73SShEtSVˏSR9u3^[_VrRYUE0E0E05S]ËUE0E0E0}]ËUEP@u+]ËUEPffu+]ËUQF3ʼnEVW~MVвEUY;uM_3^G]UQF3ʼnEVW~MVвEUY;uM_3^]UE;FtPY]ËUE;FtPY]3939øFøFøFøFøFøFËUA+уV3;#t
UFI;u^]UA+уV3;#t
UFI;u^]3939MvhbCFhbCF5F5FYYøFøFáFu
 FáFu
;F_SV5(FuF2ۊ< t*t <"uPY YtFF< Fu^[á,FuFVj 2^f;w	ft#t"uƒf;wfu^/á(Fá,FËUEPY]2ËSV5(FuF2ۊ< t*t <"uPYtFF< Fu^[á,FuFVj 2^f;w	ft#t"uƒf;wfu^ËUQQF3ʼnEESVu+ƃW39u#tEtвEUG;uM_^3[]ËUQF3ʼnEVuW>tвEׅu
;uu3M_3^]áFj Y+33FËUF3E]ËUFj Y+ȋE3F]ËUuuE]ËUE]V>t6E&^ËU3}csm]ËV>t6E&^ËUuE]jhFuuKt	uYjYe=F3@FE}u<FӃj Y+33Ë
F;t33PPPˋвEhF
uhF!YeuhEhEYYhEhEYYuFE'u,u*E0ËeM#uj$YËUqt d0@huuEPEusYuE̋Ë3jEȅu2øMZf9uA<8PEuf9HuۃxtvՃzpud0@h$ËUQQF3ʼnEeEPh$FjEt#Vh<FuEt
uвE^}t	uEM3]ËUjju]ËUEF]jjjjjjËUjju]áFËUFj Y+33F9F!uYF]ËUjju,]ËUjju]ËUE]ËUMua!RjX]áF3]ËUE=@t#=t=t$QjX]ùF3]jhFG}@t0t(t ttuu	;5FMƃ?k0U܋FD(t^VY]eEFMD(u
H	WV>YY؉]E
!u]V=Y	PËUQESVW?k04FD(\)ȁMM@tPt@t$tuBD(FD).D(FD)$D(D(FD)}uu@3H%_^[]3ËUuGY]UuGY]UuGY]jhPF/eM
EXEPjhFE0 |YeE0
.YEE06|YjhpFE0{YeM	EE0{Yjh0FgE0{YeE@EE0{YËUEMEEEPuEP]ËUEMEEEPuEPl]ËUEMEEEPuEP]ËUQuEuMP`]ËUE]UE]UEEAEAEAEA]UE]UE]UE]UE]UE]UEEAEAEAEA]UE]UE]UE]UE]UE]V6	E&Y^ËV6D&Y^ËV6D&Y^3939391yYË0N+YËUVWhj9Fj0Dt*EGEGEGEGEEPjYY_^]1xY1'yYË@1xY1xYËVFpL0-F0F00NFt?FWf83Af;:uftfxf;zufu3_tF0FLPn-0m,FPuO4FuFpLhF>-FYY^
0F
F@Cu43f9~u,hFuVit;b3ҍOff;u+sv,ff;uftfPf;Qufu3 ff;uftfPf;Qufu3Ma3ۄ0VPUYY0ۋ(PSPtm8/tj0Ph,$PQff;u+APPPuS3PPPPPV(V\jPh VGZt
uE_SVh,	uSVu$vSVjU\3f9t+;s"GPVQ tSSSSS 3ft
(,SuVg$3ˍQff;u+APSjU&VVVVVWWWWWCjhȢF1ujUpYeNtu~Ft	v;YER>t=jpYE6P$Ytxu=@FtPj"YEV?;Y
ËujpYËujpYËUQQVRjj<EYYu3G[$ENLENHHEEEPj	EEEPj uej:Y^]ËUQ}}SW3jCS<}YYu艷3VhS;YYuc3h S;YYu
>Xh@FV.uuVt*WvYYuEΉ3؉3H3EV"V3 YY3W9}YV9Y^W9Y_[3]ËUS3V9]~"W}7uuguF;u|_^[]SSSSSoA̋U(ee}v[A3Rk}E"EMPEEEE؍EE܍EEEEEEEPEPEPE]ËUSV3Fhu83YW{f3uF00EhF5\FjhQW\FEhFhQW\EHM	ff;uftfPf;Qufu3MЉM!EEE0hF1jhQW`E=Fn}uJN(tu	v(7YF$t8Ou	v$7Yf$Cf^(F _^[]S7YN(tu	v(z7YF$t8Ou	v$c7Y3F$FF(F F@3PPPPPV?̋UF3ʼnEESVuW}8t!tVPWv3Dž@4؉DMf>Laf~CVf~_KhFVQ؉0YY'+@j;Xf9@\FDž<WV3uQff;4u+;t<F~Ë0hFS	8YYuj;Xf9<_VShPj6=W3fPDuf>u3ɋ3Ʌt,PVWnDtC3
3ɋ@C@FD^uuWYM_^3[]%3PPPPPq<̋UF3ʼnES]VuW}pxx,@PjUHPhPVu3M_^3[u]Ís8>f0Df;18u5f8t'fpf;qf>8uf>uDu끍Qff;Du+A4EP3(Y>>0$O Q4ufuDHPYD,ы@ΉG88=1($Q$1 YYGFtJD(u9t(0t$008D88(8L(DPPPPP8̡F
0F
F@}t9uv蝥]0^]A=juuu^]ËU}SVWuMN}t]tM;v2/NE􃸨uQSW<3+MQP[MQPLCmtt;t+}t
MP_^[3]ËUuY]UQQeESVWPu}YYt]KCu+3ۋMQAu+jAPEm<YYuuVKuYth8FuV`Ku_}tuuVGKuF΍QAu+ʋ+ESPQV_t33V	W&YY_^[]3PPPPP.̋USVWE3Puuu}YY9ut]Kff;u+ދMQff;u+jAPES;YYu3ufVu Yth<FuVuo}tuuVuV΍Qff;Eu+ʋUSN++RQVt3ދ3VWo%YY_^[]3PPPPPk-jhF3ۈ]jYY]E9Fs
@FF=@F10
@FA
@F+=wMj
uuQoAu.SuJYYt8
tݡ0]SSSSS,š0E@Ê]jmYYjhF3ۈ]jYY]E9Fs
@FF=@Fb0
@FA
@F+=wMj
uuQ@u..SuHYYt8
t0]SSSSS+0EqÊ]jXYËUQSVW3ۍEhPFSP]5Gt
NutESV;IYYu	E8gWYtSWIYYuES8D#Y?W;#Y}tSWHYYuE8S@FWHYEYtDFV"Y_^[]SSSSS*̋UQSVW3ۍEhTFSP]Ft
NutESVGYYu	E8gW[YtSWnGYYuES8r"Y?Wi"Y}tSWEGYYuE8SHFW,GYEYtLFV*"Y_^[]SSSSS)*̋UQV3EhPFVPuEt	t3E^]VVVVV)̋UQV3EhTFVPusEt	t3E^]VVVVV)̋UVu33WtG"uA@Gut5+@jP#YYt
<"tAF>ujA!Y3_^]ËUQSVu3WˋË>fteE"f;}uA@:futG+@jP"YYu%f9tUf;tff9u3fS Y3_^[]ËUE0u]FYY]ËUE0uoEYY]ËUE0E0/FYY]ËUE0E0?EYY]ËUE0E0EYY]ËUE0E0EYY]ËUE0E0E0qD]ËUEu0E0UD]ËUE0E0E07D]ËUE0E0E0]ËUEu0E0]ËUE0E0E0d]ËUEP@u+]ËUEPffu+]ËUEP@u+]ËUEPffu+]ËUEu0E0B]ËUEu0E0B]ËUE0E0E0E0/;]ËUE0E0E0E0H;]ËUE]UE]UE]V6J&Y^ËV68&Y^ËV6&Y^3939ËUUVqAu+΍4;t"F<\uj\RCYYN3;+t5+t,+t$@tT39~jjX3@3fFFyu@uEPYuz9}ttF#ExF@tNNNt	N tN t	NtN_^[]3PPPPPh̋UEjY+tB+t9+t0+t(@tJ
]3}]jjX]3@]3]ËUQVut2^]E@tEPzYu9u3PPPPP̋UQVuƃ?k0FD(Ht33ySWjjjV!Aڋσ#˃un8uN3_[^]3fEEjPVWuf}uSWV:t3PPPV@#ƒu&뫋Uuuu]ËUQVjEPuuuuuVuu^]ËU]:UQeEPuYYu,VuWu uuuVuuVi _^]ËUjuuuuu]ËUuuu]ËUQVjEPuuuuuYuu^]ËU]=UDSVWuEuuP}ԋjY9uu跍 E0轍];u萍 3虍ϋEuԃe3AEE#jYEEPuu }ukM؋#;u5Et/EuԉMjYPu0 }u+?k0Fd(HEP諌YWEuGHEV茌Y?k0WFd(
FT8*.}
u
U;u
Fjjju:}
t
FUEM;0MFD9(@uD9(F+_^[]ËUEM?SVuWk0Mj
F[T8UUtf9uL8(d8(rډE;WBMM"j
Zf9UUtMf;Es3j
Zf9Uuj
Yfj
ZfjEEPjEPu(E}Mj
FD8(HXt:fUf;ufgj
XfFj
T8*Ft8+FZT8,;f9EuU;ufE)jjju*9j
Xf9Et	j
XfEU;] FD9(@uD9(	ff+_^[]ËUEȃ?k0EFD*]ËUEfMV?k0FL*Fl+F^D,
]ËUQQSu]Surȃ'EU?Wk0UFE|8)uVsxF3Bw;rNBFtFuV*@;uSED8(Ht5FL8*rMFFD9+uEFFD9,+ڋjRPu}7u+uVSjhhEЅuHEP萅YE;֋F2D9-$0D9-^_[]ËUEVW}G;s^OSt7
u ;sj
_f99}uj
[ff;rEȃ?k0FL([+_^]jhFXuu 	;5Fƃ?k0MFD(;Eu莄 虄|VY}eFMD(uj	L uuVG}E
)u}VQY 	ËU(S]Wu݃ 	b;FVE?k0}FUL(M%Mvu 考E}tVtD)Eu3tuШtEMEUЄu!0
jXE;rMP
jjuû讂vujjS44F}D ƉT$׋M]3E܋F]D(H]]\*]
]]}@]I}EEMFD*
EFD+E<
totkE]j_@]IEEMFD+
E:Eu>EFD,E<
t)t%E]j_@]IEEMFD,
S3YtqEMFD(t]EPuEtL}uJjEPEPuuEuHEPYVY^EMGtu_u
A|j"3ՋUUVtMt
uu|j^0^]W+>Gtu_u
{j"3ӋUUFҋM##MщF]DtjYFt!jtjY)jh@jcj~̋UVutj3X;Er4uuFt VHYtVj5FEt
){3^]ËUEMUHt]ËUEMUHt]ËUQjuQQuuPu
|]ËUQjuQQuuPu~]ËUQjuQQuuPUu]ËUQjuQQuuPCu9]ËUQjj
QQjuPji]ËUQjj
QQjuPu>]ËUQjj
QQjuPu{]ËUQjj
QQjuP}uz]ËUQjj
QQjuPRu轃]ËUQjj
QQjuPBj|]ËUQjj
QQjuPj]ËUQjj
QQjuPu]ËUQjj
QQjuPu.|]ËUQjj
QQjuPj|]ËUQjj
QQjuPnu{]ËUQjj
QQjuPCj:]ËUQjj
QQjuPu]ËUQjj
QQjuPj2y]ËUQjj
QQjuPjy]ËUQjj
QQjuPj]ËUF3E]ËUFj Y+ȋE3F]ËUA+уV3;#t
UFI;u^]ËU(F3ʼnE}Wt	uYjPjP8h0jP%0ffffffEEDž0@EEEEj|EPxEuu}t	uYM3_X]ËUuF]áF3Fd=uË\ËUQF3ʼnEVB=t5\t+uuuuuвE֋M3^ѽ]u5Fu35Fuuuu.3PPPPPyËV3VVVVVfVVVVVjktjY)VjVjVEPE^ËUV5FWu3=FBYFϋ_^]ËU;MЋ\\]ËUu`Y]UE]UE]!ËV6)&Y^jhF|3u>j+Y}EPYtxx8xHE|Ëuj+YËUE3ɉEHEHEHEHEHEHE]Ë3҃Ë!ËUQSFVW=F]A7tSF
u.VBYV 
u]
ШuVBY;uE _^[]ËE0j8jjtуHjh P7 F	VxBY1nBYËV6&Y^ËV 
u
Ѓ^ËU3S]VW}u𫫋FuCF> t3 tu>CjhtFVluj XF8t>=umF8tjhxFVu?jhFVu jhFVuF> t[wp7_^[]ËU3S]VW}ujYj FuC_f9>t3҃at!rtwC		KU2UUmfSpt\+tBt4t'
tumu4Ssm2sEPSY]mu	;UTTt@t3t"tS}&EPS뺍EPSSSUYȊm34Fmtf9>tu3f9CjhFVf9>tf>=urf9>tjhFV u
AjhFV u"jhFV uf9>tO3n_^[]ËUVWuEPt}YY}_^u3UhuEuuPcuދEFM	E3ɉHEHEHEMEAE]ËUVWuEP!}YY}_^u3UhuEuuPuދEFM	E3ɉHEHEHEMEAE]ËUE0Eu0h]ËUE0Eu0]ËUE0Eu0]ËUE0Eu0]ËUE0Eu0]ËUE0Eu0]ËUE0Eu0]ËUE0Eu0]ËUE0E0E0E0E0]ËUE0E0E0E0E0]ËUM@t2]Ã@]ËUE]ËUE8t2]ËM	]ËUE8t2]ËM	 ]ËUMt2]‰]ËUMt2]
]ËUE8t2]ËMI]ËUE8t2]ËMa]ËUE8t2]ËUuJJ]ËUMt2]
@]ËU]zU]UQF3ʼnEV5F35Fjju΋вE֋M3^躲]Fj Y+33FjhFneE0!YeE0YFjhC8EFj Y+33FFuE
NuM1v!YËUEMEEEPuEPX]ËUF3E]ËUFj Y+ȋE3F]ËUE]UE]UE]C1 YË0YjhCF8EFj Y+33FF1 YËUuMYjhCF8EFj Y+33FF]Ãhl	Fhh	Fhl	FjNh	Fh|	Fh	Fj4h	Fh	Fh	Fjh	Fh	FhXEjh	Fh	FhlEjh	Fh	Fh|Ejh	Fh	FhEjh	Fh	Fh	Fjh	Fh	Fh	Fj~h
Fh
Fh
Fj	dh$
Fh
Fh$
Fj
JhH
Fh@
FhH
Fj0hp
Fhh
Fhp
Fjh
Fh
Fh
Fj
h
Fh
Fh
Fjh
Fh
Fh
Fjh
Fh
Fh
FjhFh
FhFjh$FhFh$FjzhHFh@FhHFj`hhFh`FhEjFhpFhhFhpFj,hFhFhFjhFhFhFjhFhFhFjhFhFhFjhFhFhFjhFhFhFjhFhFhFjvh0Fh,Fh0Fj\hHFh@FhHFjBhhFh`FhhFj(ËUVu6Yu
;uu3^]ËUESVW FFʋ3;titcu;ut6YYu/;uuF3t)uPEtV@Y빋FًFj Y+3;3_^[]ËUEWt>t6E& Fu^]jh0FȬejYej^u;5FtXFtI@
tF4'YtEF PEF4YF$FE	E脬jYËUEHE`]ËU@#E+E@]UVu֋#
u#E^]UMVq$<t3KtAW9+a~0WPQYPT\;tjX	tjX!3_^]ËUVuu	V=Y.V~YtFtVP
YYu3^]jYjhpFeej@
Ye5FFEԋ]u;tt>}؅tVW5%YEG
t2uWIYt!EuGtW+Yu	E܃eEԃ땋]uu$YEEtE蠪Ë]jYjhPFAuu	VY)eV$YeVY}EIËu}Vd$YË@ËUVuW~
t$tv\Y!3FF_^]ËUEttjjjX]ËUHEPEf}ESV0X3E ;|VЂFY;~W3tVEt@t;t4uQEt!Njσ?k0EFBB(EGCE;u_^[]ËSVW3Njσ?k04F~t~tN({F(ttjjjXPE؃t
t	SE3t%^uN(@)u$N(N(@FFt
@GU_^[jhFj?
Y3ۈ]]S舁Yuh]EÊ]jF
YËV3FtP
FYrݰ^Ë@ËUEu9R]Ë@]ËUUVtMtuu3fQj^0^]W+>fftu3_ufQj"NjUUVtMtuu3fQj^0`^]W+>fftu_u3fhQj"3ˋUFVW|zuփj X+#ЋE;sЍ<2;t
9tA;u+;u>+ǃ+Wtu ;uE9tA;u+w|xuփjX+#ЋE;sЍ<2;t
9tA;u+;u+fɋǃ+(ftfu;uE9tA;u+|MU;t
8t@;u+_^]ËUQFMVWt#EэA;t3f9:t;u+j X+#E;sq3U;Mt
f9:t;Uu+;uHQ+΋+WɍJuu ;uEMHf9:t;u+wt'EэA;K3f9:@;u4jX+#E;sq3U;Mt
f9:t;Uu+;uQfɋ+΋+ȍJ(fufu;uEMHf9:t;u+EA;t3f98t;u+_^]ËUMU;t
8t@;u+]ËUMEA;t
f8t;u+]ËUVuW}j X+#;s׍2;t
8t@;u+;u?+0ǃ+Wtu ;uE9tA;u+w_^]ËUMWt#EA;t3f98t;u+Vj X+#E;sq3;tf98t;u+;uKAM+΋+WɍJuu ;uEMHf9:t;u+w^_]ËUVuW}jX+#;s׍2;t
8t@;u+;u?+0fɃ+(ftfu;uE9tA;u+΋_^]ËUMWt#EA;t3f98t;u+VjX+#E;sq3;tf98t;u+;uKAfɋM+΋+ȍJ(fufu;uEMHf9:t;u+^_]wtuftfufWfËUFVW||uփj X+#ЋE;sЍ<2;t
9tA;u+;+ǃ+Wtu ;uE9tA;u+w|uuփjX+#ЋE;sЍ<2;t
9tA;u+;uZ+fɋǃ+(ftfu;uE9tA;u+UʋE;t
9tA;u+_^]ËUQFMVWt'EэA;}3f9:r;ufj X+#E;sq3U;Mt
f9:t;Uu+;'Q+΋+WɍJuu ;uEMHf9:t;u+wt'EэA;3f9:;ujX+#E;sq3U;Mt
f9:t;Uu+;ufQfɋ+΋+ȍJ(fufu;uEMHf9:t;u+EэA;t3f9:t;u+_^]ËVWF3jhWtF8r۰
jY2_^ËUkEFPE]ËV5Ft kWFWE
Fu_^ËUkEFPE]jYjYËUS]uG|VWj=SMEYYtN;tJx5FE;5FuV!EY5F3ۅ9]t/9Ft'yunGW]Y_^[]Ät3jjSF75Ft9Fu%jjSF9Ft5FtE+PQEYYxH9tD4YM8]uEDA9ujQVSDžtXP8].؉EH;?jQVdSdME\5F9]ȍQAu+jAPEYYtGuuVu@M+EAEЈY#PVu+_^[]+USVW=F?t-]S6uuX=tft>u+_^[]+ssUE0E0uEu2	EHxuEu`2 2EH|ރـ} $ fPuujQDuuhF|wbtpHtZHtDuEHwnu	fuujY} $0fPuujuuhFuu VF}]WSujIuWShFu VWSujMu(WShFu VWSujSu(_WShFu VWSujpuuujXuE@jaELPuuPx4ME3Pu?YE9p t EuP?YMMMM3+™j<^ɹFxFuuQj0uujVj0uujW4QEHui} $0fPulujNu3u8E uuPubx{MDC%tQEH} $0fPulujjdYEH}uEu:EHZQuEuuuhFu uu}VWujmuVW FSu uVWujdu(VWSu uVWujyFtvtJE@jYuр} $0fPuujqEHTK} $0mEx+xj0uujppplu uu}VWujYuVWFSu uVWujmu(VVWSu uVWujdEH~;%jR_;x$Du uuuujHuIuuhF6u uuuujMdE
wq[fff
;r	+ȉ&_^]ËUM9t"UVuW:ftf8)u_^]ËU0F3ʼnEEUEЋES]E܋EUԉ]VuuWtt\XT}lfBfEfBf@MfEfBfEfBfEfBfEffE3fEEt3QQWPQ`I3QQQWPQ`@؅kJ;tXJ;#J=w#;#cu$;#PuY3ut~}EtSVWPEj`jSVWPEj`ЋJ~#]u܃;vffJuVBYe_^[M3o]j$uYn>tE3ɉ}ƒAf9t‰]]؃d/'AtHtXMt"ah|FWQYYuSO
Mbt!t tjBjbEjmt
t	EjHhFW[QYYuGEjpx%yH@hj'Xf;YffuBt!t tjAjaEjdht'ItIjYjyEԃxLPu>v}ff
f]܃>v}f
fuftt&EjS6ttEjM"ttM܃f%EjIXuSVuuPut}f[$2KUEH;#]ËUEtM]ËUSVW3ۍMS]wEj_EVJff;Eu+ыAEff;Eu+M؃u]P73Yuj:EEYfp΋++@PV΍Qff;Eu+j:X4NfE+0+@PVuY΍Qff;EuE+j:E4NMAMYg3fP>}Yt
M䃡P_^[]3PPPPP+̋USVW3ۍMS]Ej_EVЍJff;Eu+ыAEff;Eu+M؃u]P֥3Yuj:EEYfpЋ΋++@PV΍Qff;Eu+j:X4NfE+0+@PVzuY΍Qff;EuE+j:E4NMAMYg3fPݤ}Yt
M䃡P_^[]3PPPPPʬ̋U(VW3MVE܋։udUSƉMEu+W豤EYWVPEM}d։E)MىU}u%8E3E+PQ
ZUAEAu+MGEBUr]։U}u'EMω3E+PQ认UAEAu+MGBUr]։U8}u'EMω3E+PQUUAEAu+MGBUr]։Uh}u'EMω3E+PQLUAEAu+MGBUr]։UØ}u'EMω3E+PQ蠣UAEAu+MGBUr}]u)E;E+PQJEQAu+G}u)E;E+PQSEQAu+G}u)E;E+PQ輢EQAu+ʋUYM߃uE}uǴCuu(AEE7+PQQff;uE+ʋUKM@Er}uCu}u+MAEE7+PQBQff;uE+K@Er}uCu}u+MAEE7+PQQff;uE+K@Er}uCu}u+MAEE7+PQfAQff;uE+K@Er}uLCu}u+MAEE7+PQQff;uE+K@ErCu}}u/GETTE+PQjETQff;u+KCu}u/GEXXE+PQ1EXQff;u+KCu}u/GE\\E+PQE\Qff;u+KCu}u+GE``E+PQuuTE`Qff;u+ʋUBUy<{}EM]u}[t
M؃P_^]VVVVV̥̋Ujuuuuu]ËU$W}u^3U}tVu3fut43*uMTUuEUES3ۉME>}}}f%}tEfMEHMEX9]]f>#uEEtOuuERPEPuPEPGEt"MUbt]3f+]4t3fuu
c"V}t
M܃P[^_]ËUEt8uPY]ËUujuuuuD]ËUjjuuuu%]ËUQHLMMQP7EYY]ËUMSu]sKEPSkYYt$}E苀t
E䃠P}t
M䃡P3fEEEx~.ÍMEQPtYYtEE3j]EY3*3]AEfEUEEjpjRQMQuEP$u8EgE䃠PXu}Et+M䃡PUEЀ}t
M䃡P[]ËUMSuK]sKEPS>YYt$}E苀t
E䃠P}t
M䃡P3fEEEx~.ÍMEQP*YYtEE3j]EY3*3]AEfEUEEjpjRQMQuEP$u8EgE䃠PXu}Et+M䃡PUEЀ}t
M䃡P[]ËUuju/]ËUuju/]ËUEE]ËUEE]ËUE ]ËUuhu(]ËUE]ËUuhu]ËU졨FtjuYYMAw ]ËU졨FtjuYYMAw]ËUSVut]t>uEt3f3^[]WuME􃸨uMtf3GEPPYYt@}~';_|%39EPuwVj	whE}u;_r.~t(139E3PuEGWVj	phEu%*}t
MP_1Ujuuu]ËUuMeEPEupEuP#tE}t
M샡P]ËUS]W}utEt 3zEtVvYj^0SuM?E39u]fEf;v6ttWVSaqj*^0}t
M샡P^_[]Ått_Et΍MuQVWSjMQVpرEȅt9uuEtHEzuttWVSpj"^0FlUQejuiPuEPtE]ËUjuuuu]ËUESV3ҋp#W;uC;u?Áu@0΋t
;u	;ujX#tjj3_^[]ËUE3ҋHtB]ËU0SVW}3ۅyuMu(rG9Ewhj"_8)UJE%=uR;uNSu$SWuuuVR$tbjeViYYt8] ɀpX:t-FJ38] j0EK3']XuFB
%u!M
E1FFMuEԋB%Ew	:ej0XEM~SR#E#ыMBKj0Yf9vËMUFEEEOMEfyfxWR#E#ыMJfv6j0F[ftFuH];Et9u:	@~Wj0XPVmE8u} 4U$pRrJ3ہ+Mxr	F+F-كۋj0X|?;rjPSQG0UF;u|drjjdSQG0UF;u|
rjj
SQpG0UFj0X3F}t
MЃP_^[]ËUEVuWuu~PEWp0v9MtM3}-+3+ȍEPW}Q3Ƀ}-3Ptu(EjPu$u VuW	 _^]ËUVW}~3	9Ew
j"^0蚘_^]Su$MU ]t%M3P39-PuSU E8-u-s~FFE􋀈39Et+EhFPV[uvN8EtEUB80t/RyF-jd_;|™Fj
_;|™FV}u90ujAPQ賀}t
EP33PPPPP諗̋U3VWu}uE}PEWp09MtM3}-+ȋuEPEP3}-QPtu EjPWuV	_^]ËUMSVWuU}]JI}t;u3:-f0:-u-sBjVuS:0F~RjVuSEFEHy)}u;}WVuSWj0Vi}_^[t
EP3]ËUSVWu3}uE}PEWp0&E3ɋ]}-HE49EtE+MQWPV]tUEH9E|*;}&t
FuFu(EjPWuSu(EjPu$u WuS _^[]ËUHF3ʼnEUMS]Ã;sjXM3[R]Ät-AJlFE|FE38]EpFEÉEKxFEFEԃE؉EEEVtFEFWF4FEFu+uF3u3;vj"XF4QRls_[^]ËUusrY]UEVWH+jd__+^]ËUVtuV4YY#^]ËUVtuV'YY#^]ËUQQVuuj^0yS]Wj	Yuj^0y'E=@W|jY;|=&Avj^0EEPEP}FYYQFi}LFuLFV3A9P}A9|INj+QVYf ǹVj_[^]ËUVuuj^0x"Wj	Y}uj^0kx3OEM	|=@WrjZ;|=&Avpj^0SEEPEP=]YYjFQPuS&FQ鹸LF+؋E€}EuLFV3@9Q}@9|HFj+QPVw7r&j}YjVPWST&Fj+j<WS;&f Fk<+3[_^]ËUE]V6co&Y^ËUVW}7ƙiȀF+3Ɖ7;|+B;|B=|
B{M_^]ËUQS]3VWjs;PVW%3HFAMQ+;sMQY)SK2|s,u3‰NVKzYt";ESuV^YtM_^[]Ë!ËV6Dn&Y^ËVt!F8u'j$\njF8nF8YYu
%3^ËUVtuVYY#^]ËU]UVtuVYY#^]ËU]UQSE3P]Y9]nVuW3GN;
Fu;
F'9FFPFPFPFPf9FuFSPFPFPQWFPFSSPQSShjF,PhFPfFPdFPf9\Fu`FSPbFP^FPvWbFP^FSSPvSW,OjXjZ3jC_k}jXj
_3jB[jjjjjjRPQjj3PPPjPPSWvjjXF=FN;};|&;";~";}3@_^[];|;;~;}3kF<Fk<i3;u;5F;5FSSSSSs̋UM]ËUM]ËUM]ËUQQe}VW}uySWY]EYtLFLFWFYimj6YMk+;UE}tLFLF[u*;~&!WEYt	4LF4LFu kE$<E(k<E,iE0}u5FF=F_^]ãFEP5FYuDiE
Fȉ
Fy\&
F\&;|+F
F=FjjjjjFr̋UQQWFEWhuP	uE@"t37Vu/jYtWuEVP֍u33ViY^_]ËUSVe؃eEP]>YEPYFut4ʋƊ:utX:Yuu3D]R;iY΍QAu+ʍAP]ijFiFYYWyAu+VAPRij_WVj@3>tFu>-_ÄtFVmYiM<+t<0|<9F>:uBFVmk:uFVmYMȉM<9F<0}tىM38EEtjVj@p
t @uI0u30^[]3PPPPPp̋USV!3ۍE]P]]iY"EPYEPY5FgF$FlEk
F<lFW3G=FMf9^Ftk<ȉMf9FtFt
+‰}kGt%u>Gt
tuҋUu_[uu
EjPDXJj"둋U]DUMftfy:uarzw ]3]ËUF3ʼnEE|:5@fEj:XfE3fEEPhEuHEPY3
jdM3!]ËUF3ʼnEW33hfWP7Ph`E=wPYBSVXjS]YYtVS`Eu
	VYV[Y^[M3_O!]ËUEt38t.}tuPu~]uuuuP{]ËE;rPuYY]ËUEt4f8t.}tuPu]uuuuP]ËE;rPuYY]ËUW3WWWuEuHEPY3JS]V;wjS	pYYu
SuVt΋V	Y^[_]ËUW3WWWuEuHEPZY3JS]V;wjSoYYu
kSuVzt΋VY^[_]ËUVuu,a3;v
"juVuE;suHEPYċE^]ËUVuua3;v
"juVuE;suHEPSYċE^]ËUE0E0YY]ËUE0E0YY]ËUjuuuE]ËUjuuuE]ËUEt08t+}tuPu]jjjuP]ËE;rPuYY]ËUEt/3f9t(9MtuPu]QQjuP]ËE;rPuYY]ËUE3SVWf9t,u>ftf;tfu3f9u3_^[]ËU졨FuuUu_]ËMtSVWjA_jZ+[
f;r
f;w f;rf;w ftf;t_^+[]juu]ËUMSVu聮]tuuq1_EWuBjAYjZ+Z3f;r
f;w f;rf;w ft:f;t3MQPM[QPvftf;t+_}^[t
MP‹]ËUQ}uh^3VuuI^3SWo3WWjuC>WShEEuHEP3GPXVYt0uVjuWShEuHEPYMƋ3GVUY_[^]ËUQ}u]3Vuu]3jWou&GWMEYYuHEPQ38PUYt!uVuWSuHEP Y3V2UY_^]ËM3ƋGUuUY]UE]V6T&Y^39Ë!Ë39ËV6T&Y^ËUQQSWj0j@JV3ۉ}YYuH;t>Vw ShFPsNv0^ԍFF

F
f^;ű}^SKTY_[]ËUVut%SW;tWE0;uVTY_[^]jhFf&} u
j	^0[&3ujlYuF}9E|94Fu1Fuj^uE묡F@FG뻋ujZYËUEȃ?k0FPE]ËUQSVuxi;5FsaƋރ?k0FM|uCWg}u"tt
uWjWjWj|EFM|3_	 ^[]ËUEȃ?k0FPE]jhF$j#Y}3ۉ]]ԁ}MFE؅uSFt/F@WYǃ?k0FD(}E$ÍMj0Xu;t`F(uVEF(tVEMj0X+u؋ƙj0Y4΃?k0FD(F|tC}jnYËUSVuWxg;5Fs_Ƌ?k0FD(tD|t=u#3+tt
uPjPjPj|EFL3)	 _^[]ËUMu 	Cx';
Fs?k0FD(tD] 	yX]jhxF"2Et E@tˀEtuEuHEP.Yu@uuu5 EeuVYYƃ?k0F\(FD)Fd-EEW"ËuEuƃ?k0Fd(VYËU<F3ʼnES]VulWF+CuCPVE}};};fft,u%>fft
tuҋUu3f_[ruE3jPfTAX3fj"zU](USVnEuttVEtjXluE؃tQEW3EEWWEEPhlDWWu}EtWjVEu}tVuSPuMVUjBY^[_]3PPPPPJ̋UQMSW3ۍQff;u}+A+ljM;vjXWV_jSDYYtWuSVu5u+ߍ~uSPtuMVj*BY^_[]3PPPPP'J̋UPF3ʼnEMS]VuWt6E^ËVW76=Y;wu7t6E^ËUuE]ËAËAËVW~9~t3r>u+jjW=j;ujXMFF+>wSj?S6r8uj^NF3jW;Y[_^ËVW~9~t3r>u+jjwSj?S67uj^NF3j:Y[_^ËÃËU]霱UE]ËA+ËA+ËU]2U]*U]U]XjhFE0nYeMEE0oYËUEMEEEPuEP]ËUE]UE]UE]1nY1XnYËVj@H@F@H@F@HF@HPjhF*Q@HPQhFQ@HPQhFF0uF=FtP9Y@HF@H^ËUE-t(t
tt3]áF]áF]áF]áF]ËUMj迏%FEuFE,uFEuEF@}t
MP]ËUS]VWh3sWV{3{{F+7Fu9Au_^[]ËU F3ʼnESVuWPvܰE3ۿÈ@;rƅ Q
;s
Ƅ @;vuSvPWPjSSvWPWPWSdt@SvWPWPhS]ËU}	uj@X]jj@uj]ËU}	uj@X]jj@uu]ËUjhuj]ËUjhuu]ËUjjuj]ËUjjuu]ËUjuYY]ËUuM>EtxujjuuE3ɀ}t
EP]ËUjjuj]ËUjjuu]ËUjjuj]ËUjjuu]ËUjjuj]ËUjjuu]ËUjhWuj}]ËUjhWuua]ËUjjujI]ËUjjuu0]ËUjjuj]ËUjjuu]ËUE]V>t6԰E&^39ËV>t6԰E&^ËUu԰E]ËUUW3f9:t!Vʍqff;u+Jf9:u^B_]Ë339ËUQSVWذE3tVVYWWWW+SVWWرEEt4P.Yt3PPuWSVPPرEt33W-Y߅tV԰E_^[]ËVWذEu37SV+S-YYtSVWjZ-YV԰E[_^øFËUu9-Y]Uu'-Y]UE]UE]V6,&Y^ËV6,&Y^Ë!Ë!ËV6,&Y^ËV6,&Y^ËUQpHLMMQP-rEYY@]ËUQpHLMMQPrEYY@]ËUQpHLMMQPqEYY]ËUQkpHLMMQPqEYY@]ËUEu]@]ËUHF3ʼnESVu3Wuĉ]䋎]]܉]Љu]F]9uPhQESP2jj+-SE+jW-SEl+jW-SE[+jW,SEJ+jh,S}3+<9]N9]E=9]49]+È8@=|EPvܰE	ESvOEԺERPRQhSg$EܹSvQPQGPhSg$}~+8]t&MtQ: B;~8Yu݋ESvPhWjSE5U3ɍfMEE܈Y逃}XMM̈~@8]t;Mt/q;E(PjWEjP'PE)PjWEjP
E*PjTWEjPE+PjUWEjPߝE,PjVWEjPȝPE-PjWWEjP讝E.PjRWEjP藝E/PjSWEjP耝E8PjWjEPiPE$EP5$rU<0|<9,0B:u"<;uFv>u}FjY󥋃3ɋuA}@F@F@0F0@4F4EttK|tux#s|p#YYEC|3_^[]ËUU:tV<0|<9
,0B:u^]<;uFv>uUVutY;FtP"YF;FtP"YF;FtP"YF0;FtP"YF4;FtP"Y^]ËUS]3VW]E9u9uEFV3FjPVu
$EYYu~jYj"3Wu<"YYuu."3Y@F>9TjJ"Wu"YYu>E苻jWjPuMEQjWjP^EPjWEEjPDE0PjWEjP-PE4PjWEjPt%uXMYud!MQ[!EYYuU<0|o<9k,0B:u}uM3@ttK|tus|! YYEC|3_^[]<;uFv>u녋uFFFFFFF0FF4aUU:tV<0|<9
,0B:u^]<;uFv>uUuM Y]UjuYY]ËUjuYY]ËUjumYY]ËUjuZYY]ËUjuGYY]ËUju4YY]ËUE]V6&Y^39Ë!ËUESVuW3+΃;#t6xGvY;u_^[]ËËUW}uF5Vhdj YYtWV,YYuVY3VY^_]dž3UEeSVWVuEuftfzf;~ufuދ҃t_+Ff:f;>uftfzf;~u
fuu"jEPEh PP-t+E7Q.Y.jEPEh PP,u3
EuE_^]ËUF3ʼnEVuEj	PjYV,tj	EVP@M3^]ËUuYu/9Et*EVVffu+QY;^u3]3@]ËUQVu3WB3xNStH7+‹؋EkM4E0賶YYuEMȋE
ys{;~[3_^]ËUQQSVWR]3ɉMpPPNf~Ef9tWjh*FI3ɋVf9tGf9tw3Y9Fu2Vj@h'Ft3Vf9tEY39~VP_YYPEEt0}M 3fQff;Eu+APujUSj@WhS~*thj@Sh P`*tJj_SYYuj.SYYtj@Sj P/*tj
jPV'3@3_^[]3PPPPP̋UF3ʼnESVuWPPVL/YKdٍjxɁPQV,Eu!@3PsTuftfzf;~ufuދ҃t]+Ff:f;>uftfzf;~u
fuu jEPEh p,Et)E5Q
Y,jEPEh p,Eu3
EuE_^]ËUM3f;+Ft
r3@]3]ËUQVW9JujEPh Q,Eu30;ut(}t"wPNffuwP+Y;t3@_^]ËUSVu3Wx13+‹Ek4E0VYYtyw_;~2_^[]ËMkM̋UF3ʼnEES]VuWERIP}E3?IM3҉LE0xtf9t+FWHPh*F3E3҉Utnf9titf9tEP	EP}Y*FuHPh'FtN3tf98tEP	EP:Y,tf9tEPYE4EEE3}u3M_^3[]3EP#VYYt́tŁtPEtju0EtEt0EWjUPPu#t^WjU Put#j@Shu,ETj@Phu,E5j
jQV3@UQfGHLMMQPHEYY]ËU]UVutj3X;Es3BS]WtS>}Y3uVS?YYt;s+;VjP_[^]áFаEFÃ%FáFËUQF3ʼnEW};}uWVStвEӄt;uu;uu,;t&~tt
jвEYF;u2[^M3_q]ËUQF3ʼnEVu9ut#W>t
jвEYF;Eu_M3^$]áFj Y+33FËUF3E]ËUFj Y+ȋE3F]áFj Y+33FPYËUA+уV3;#t
UFI;u^]ËUuF]ËUQF3ʼnEV.tuвEYt3@3M3^,]jh8Fej%5Ye5F΃35FΉuEËuj45YjhXFej4Ye5F΃35FΉuuYFEËuj4YáFj Y+33FjhبF0eE0X4Ye5F΃35FΉuE
:uM1b4YËUEMEEEPuEP]ËUF3E]ËUFj Y+ȋE3F]ËUE]UE]13YáF3F13YjhF 3uujW3YuF‹ȃ}uF35Fj
F35FjΉu_}܅tt
j Y+33‰Eu3#u}j*3YÃtWвEY3@ʶUEHt-t	ttt3]øF]øF]øF]øF]ËUA+уV3;#t
UFI;u^]Uk
(FE;tU9Pt	;u3]ËUEtt
t~~z]ËËUQEPjYY]ËUuFJuF=uF0uF#]BA9Aj,hF?3ۉ]!]̱Muj_;t5Ft"Ht'HuLtt
~;6VxEZA؉]ԅu3VYY3ɅuyGу2ɈME؃etj0YMeEeE؄tFʃ3ʊM‰E3҃‰UȈUutj0Yj;t
tu#CEЃc;u;E;u"k0Fk
4FȉE;t%`Fj Y+33FM؉E1}uk;u6?pWMвEUY+j_u]ԊEEȀ}tj0YVMвEUY;t
tuEЉC;u;?M̉H3荳jhxFG]}tttW@F?t>Fu&5,FYt5,FhFPEPWYYtP
M؃t"k5(Fu;t9zuJ;uM؋3ۈ]u؉uj.Y]tu:=Fu1jhTD̰Et	FvHE]uW|E؅t&5F΃30ΉuEtP]؃	vW0FGut;}r;}}rE^fj"^0NNG;r3_^[]ËUM3US]VEW8Etj-Xfs3@ىEڋ}ujuRQ藝MȋE]	vW0fGut;}r;}}rE3fej"^0m 3ffff;r3_^[]ËUMVueej^0&33PPPPP̋UQVW}u^j^0]u3Et9EtSuYtVˍQff;Eu+jAPEYYuo^jY[_^]Ë}SWPu
t>33PPPPP1jhFv3uu^3@WV_YY;tփejiYeVYuEUËujYjhF3uu]Y3@WVYY;tփejYeVYuEղËujYËUQVWxtN}tHuNFu+2ʍAEAu+M;v<2=uVuRt?u3_^]Ë@UQQVWtd}t^u3҉UNff;u+9t@ʍAEff;Eu+M;vfyYËUEMEEEPuEPD]ËUE]UE]UE]1"xYËV0ƃ?k0FD(t%VwzYPEt3^bHHEfH^	1{xYËUQVuu
>H	Kx7;5Fs/Ƌփ?k0FD(tEEEPVYYG	^]ËUQFVWUuGMtߋ};vGUmSjA[jZ^+щujZ^
f;r
f;w f;rf;Ew t
ftf;t+[juuu	_^]ËUS]u3}uFW}uFV;vFkuM E􋀤u\E+jAE^8jZZf;r
f;w f;r
f;w Ѓt
ftEf;t+(SWSuhPPu
Fp}t
MP^_[]ËU졨Fu]juuu]ËUMSVWuEu3MtUuEFh;vfE&M}􋟤uuVPRQϟ-wPRPQhESPR u
Ep}t
MP_^[]ËUhuQYYu	f}_t]3@]ËUhuQYYu	f}_t]3@]ËUuMEMH%}t
MP]ËUhuqQYY]ËUhu[QYY]ËUf}	j@uX]u>QYY]ËUj u+QYY]ËUhuQYYu	f}_t]3@]ËUhuPYYu	f}_t]3@]ËUjuPYY]ËUhuPYY]ËUjuPYY]ËUhWuPYY]ËUjuzPYY]ËUjugPYY]ËUjuTPYY]ËUhu>PYY]ËUjuoYY]ËUhuPYY]ËUhuOYY]ËU츀f9E]ËUf}	j@uX]uOYY]ËUj uOYY]ËUjuOYY]ËUhuOYY]ËUjuOYY]ËUhWuiOYY]ËUjuVOYY]ËUjuCOYY]ËUju0OYY]ËUhuOYY]39ËUQQF3ʼnESVuW~VuOY;Yp|}$uEx}$39E(jjVuPWhEEJ;tRJ;#J=w;#|܅L;#PcY-3ۅuSVujWhE}3PPPPPWSuu1Et8E ;3QQQPuWSuu6J;tJJ;#J=w;#|td;#PYtI3t8jjjVWuSuuqt3PP9E u:PPVWPu$رEu.W&Y3S&Yƍe_^[M3]]u uW&YҋUuMu(Eu$u uuuuuP$}t
MP]ËUUVu?j^0@}vM~3@9Ew	M?j"̋utSZW~0~tG0@IZx?5|
0H89t:1uFˍqAu+΍APSR蹲_3[^]ËUP	F3ʼnEMESVW}ω%u3	2Ҿ3]E3@jMQQ$pNYY9z=t=u303ۅ4C,j^Dž;
3ɋ
;
0u䋍3҃j ^Ɖ+3@xHωЉtA3+9PsŃsut2ɄjrY;rщʉ0+;rm;s83F;s@3##苍狍lj0INt,돋tȍ03󫀽tB,3,+3P,P0SP$3jXA\PP`SP|$c3Aj _lj+3@v,HɉЉtA3+9ōssut2jrY;rщʉ+0;rg;s3G;sB3##苍㋍É0IOt,땋j^tȍ03󫀽tB,3,+3P,P0SP"3@\jjYDž;3ҋ;0u䃥tP3j X+‹;8;s
F;sW3ҋ3ЋNt,38+,VjPB3@5G@,tH3j X+ssut2jrY;s˃ti0<;s
F;sW3ҋ3ЋNt,뮋tA,3,+,jP0hPr 3G+VjP3@5C\PP`SP 3j
Yc񉅜ʉq&vj&XE4EW1jPMPEEPPStwzu3\\\3ɉ3``G;u`\Z\`P\P`SPu3\P\\3ɉ3``F;u\s=3\P;\`u\t\33+u%;!V`33Ή9stW;u@Ɖǃ@A;ut4s;uA3AȃsF;‰\PP`SPtl+<\Eu]3\P:3\PP`SP(2됃\jP`\33``F;ub\sK`\A񉅜ʉL&vj&XE4EW1jPPEEPPou3,Prz,m,3ɉ300G;u5,s0,,w|0P,P0SP<=,,3ɉ300F;uR;,0u,t,33+u%;!V033Ή9stW;u@Ɖǃ@A;ut4s
;uA3AȃsF;‰,PP0SPZ+\E,330Ɖ0G;ut,ssN0,e3P,P0SP27,j3P,P0SPW,to330j
Zlj0F;uድt@,ss0,&3P,P0SP\P,PrYYj
Z;w\13ɋ3`j
`GZ;uድt\\ss`\B3P\P`SP!u	H0wMx
wȋEH;r;,3ɋ30ʚ;0G;uߋt@,ss0,&3P,P0SPI\P,PYYj_+30;r7Ou	vj	Y񉵴;-M_3^[t]ËVVN:Y<uFV:YF^ÀytQ@:Y̋UMVW}7;1t_2^]3҅tA+;uB;u_^]̋UMVW}1;7t
23_^]3҅tA+I;uB;u3_^]̋UM39]̋UQS]VuW<EWFjPf˺ƋMT7A_^[]ËUd	F3ʼnES]lVW}u3΁-uΉ3_}u"΋ǁuh`LF`EPGYt
AzE|@}uEݕω%u3	2Ҿ33@8QQ$9YYe=t=u303ۅ4C,j^Dž;3ɋ
;
0u䋅3҃j Y+ȉ3@cHωЉtA3j X+V9ssut2jrY;rщʉ0+;rm;s83F;s@3##苍狍lj0INt,돋t΍03󫀽tB,3,+3P,P0SP)3jXA\PP`SP\3@j Y+ȉ3@b,HɉЉtA3j X+;9ssut2jrY;rщ‰0+;rg;s93F;sA3##狍苍0HNt,땋j^t30󫀽tB,3,+3P,P0SPE3@\jjYDž;3ҋ;0u䃥tP3j X+‹;8;s
F;sW3ҋ3ЋNt,38+,VjP迂3@5G@,tH3j X+ssut2jrY;s˃ti0<;s
F;sW3ҋ3ЋNt,뮋tA,3,+,jP0hP3G+VjPv3@5C\PP`SP3j
Yc񉅐ʉq&vj&XE4EW1jPʀPEEPP_wzu3\\\3ɉ3``F;u`\Z\`P\P`SP7
u3\P\\3ɉ3``F;u\s=3\P;\`u\t\33+|u%;!V`33Ή9stW;u@Ɖǃ@A;ut4s;uA3Aȃs|F;‰\PP`SPtl+<\Eu]3\P:3\PP`SP2됃\jP`\33ɋ`Ɖ`A;ub\sK`\A񉅬ʉL&vj&XE4EW1jPe|PEEPPk[u3,Prz,m,3ɉ300F;u5,s0,,w|0P,P0SP=,,3ɉ300F;uR;,0u,t,33+|u%;!V033Ή9stW;u@Ɖǃ@A;ut4s
;uA3Aȃs|F;‰,PP0SP+\E,330lj0F;ut,ssN0,e3P,P0SP27,j3P,P0SP,tw330j
ZƉ0G;uትtB,ss‰0,&3P,P0SPG\P,PYYj
Z;w\133ɋ`j
lj`AZ;uድt\\ss`\B3P\P`SPu	H0wAx
wȋEH;r;,33ɋ0ʚ;lj0A;uߋt@,ss0,&3P,P0SP\P,P\YYj_+30;r7Ou	vj	Y񉵴;-*h|LFhtLFhlLFhdLFuS`u't_^[t
lP%YM3_]3PPPPPW̋UVuu3mEuAj^0SW}t9urVWPT36ujPVuu	j9usj"^0賡jX_^]ËUEVu苡Y@S3
CCE@2E@ËEtjY		E@u	uYEHuvvVYP$FEP@u]uYt5uYt'uWVV?k0YYF_F@($E8MEUË]j迷YjhF3U3uj]YuEuu}WN؉]tM9!uEtp,>E8MEUË]j/YËUVW}W
YujX>uWgYS3&hVYYujhVYYt7SV谧YYtUt.}t"΍YAu+;rtj"UjQ3VWR:pt?x(t8ujh0S舁tVhPUu
jX[_^]SSSSSk̋UQVW}WSYujXS3ۉ]f9uWYjhV#YYtSVYYtUt4}t(΍Yff;Eu+;r
t3fj"Q3VWR:t?x,t8ujhAS虀tVhP۫ujX[_^]SSSSSz̋UVuj.V
VYYȅu	.2-;r+9EvSWj$3ۍySW_u2_[^]j$+uVWRPuSSSSS̋UQj.u?YYȅu	跇2?;Mr+EW};w	蜇2#Sj$YjSȉEu2[_]Ë+Ej$+WSRu趛u3PPPPPp̋UE0E0YY]ËUE0E00E]ËUVu<Fujh讀jFF^]ËUVu<(Fujhtj(F~(F^]ËUSW}W|Yt{Shm
YYtg=w`V4tt
uutsF+ށEj$SV3SPNu&΍QAu+f.0\^2_[]SSSSS*̋USW}WYSh0E=wzV4Ctt	ujxjwjvXfƿ++Ej$WV3SPޙu:΍Qff;u+j.NYfj0YfH3fH^3f2_[]SSSSSd̋UE0E0YY]ËUE0E0YY]ËUE0E0E0}]ËUE0E0E0@]ËUEEQ0RYY]ËUEfȋEQ0<YY]ËUE0E0E0]ËUE0E0E0]ËUE0E0E0Ep0O]ËUE0E0E0Ep0k]ËUE0E0E0Ej0]ËUE0E0E0Ej0!]ËUEEAEA]UEEAEA]AQ	+ËAQV0+2+^jhFM3uuzj^0;MÃ&ejگYeuV,YYut<0E뼋ujYjhF^MjYujX?ujYujhW]YEP蔃Y}uj3u܉u0uhuhBWEPiu܃uhWYYut8uj}t[uWlYFE39PuuxYj^3PEPE
FE	MEAMEuELËu܋ExuPYuYËUEF]ËUE(F]WuÃ(IuÃ,ËU]{9DFËSVWj_F6Uy&vYu(F6=y&vYu_^[ËUQeEPjhu6E]ËUQ}uЀjXEPjuu]ËUQeEj@P:EYY]ËUju"YY]ËUQeEPjhuE]ËUQ}u?jXEPjuu]ËUVu~
VuɪYYE~Pu赪YYtt3QQQPuVuuu軑+ujX3E^]ËU,F3ʼnEESVuE؋EEԋEEW}}~"VWYEY] ~SPYY}32|E$uE؋@E$t;ujX~3@~jMQPܰEt~/jX9Er}Mt؊Qtъ:r:Ȁ9u뺅~5jX9Er}Mtu܊Qt:r:~Ȁ9ut3WWVuj	u$hEE؅J;tYJ;#J=w ;#/ĉE;#PvEYElj}uPVuu$jVhEWWSuj	VhEEJ;tJJ;#J=w;#s.t`;#PuYtEt4uVSuju$hEt]WWWuVuSuu']V8Y]S,YǍe_^[M3:]ËUuM1u$Eu uuuuuP' }t
MP]ËUM38t;Et@<u]ËUVuIF3^]ËUQQeeVu6vGEP;EuF;Eu33@^]ËUQQeEePYt3@)MUEAEPUxYu誂3]̃=tF\$D$%=u<$f$ffd$uUy=tFt2\$D$%=u<$f$ffd$u%$B

ÍT$	R<$tLD$f<$t-(OFt^uA=4F

MF	
uԩu|$u%t-NF"X	uŃ|$u-NF=4F	
MF
ZÃ=tF
\$D$%=u<$f$ffd$~D$f(0MFf(f(fs4f~fTPMFffʩtL=|}f=2fL$D$f.{$T$ԃT$T$$
D$~D$ff(f=|%=2fT MFXfL$D$`MFf@MFfT MFf\$D$3PPjPjh@hhMFE`Fá`FttPYYtAtVdYu6XYM_3^'][ËUQQE]E]ËUE tjt3@]ètjtjX]]ËSQQUkl$F3ʼnEVs CWVPsu&ePCPCPsC sPEPs s^YWt)t%CV\$\$C$sW$WQ$VFCYYM_3^&][ËSQQUkl$F3ʼnEVs(C WVPsCu4EEC jPCPsC(s]PEPs(s}Yvt*t&C V\$C\$C$sW$Wo$VdC YYM_3^%][ËUM39XFt
@|3]ËXF]ËUS]VtEtj.Y#EtjYwEjEY#tT=t7=t;ubMYF{LHM{,YF2MzYFMzYFYFEW3tGMDEPQQ$EEU=}3GY3AuBEfEE;}++ȋEEtuGEEt
EmuEtE3G_tjYtE tj Y3^[]ËUEE]ËUjuuuuuu]ËUE3S3CHEW
HEHMtE	XtEHtEHtEHtEHMVu3A1AM3A1AM3A1AM3A1AM3A#1AtMItEHtEHtEH tE	X#t5=t"=t;u)E!MME #t =t;u"E MMEM31E	X } t,E` EEXE	X`E]``EXP:MA A EEXE	X`M]A`A`EXPEPjjWdEMAt&At&At&At&At&ߋt5t"t
u( %
%
!tt	u!#
	#
} ^tAPAP_[]ËUjuuuuuu]ËUEtw"]!]ËUU 3ɋ9XFt@|XFMtUEEEEEEEVuEE hu(EE$uEmEPbuVUYE^hu(Cu9E ]ËUMEEPQQ$]ËUEWDz	3VfuƩu|MUutjٿAu3@3EuɉMyMOEtfuUf#futffuEjQQ$s#jQQ$`^E8_]ËUE%-]ËUQQMEE%]fME]ËUQQMEE%]fME]ËU}Euu@]Á}u	ujX]fMf#f;ujf;uEutj3]ËUQQE]EE3Ё3ȉME]ËUQE3Ё3ȉME]ËUQQE]EE3E%3EEE]ËUQE3E%3EEE]ËU3f#Mf;]ËUfMff#f;u3EQQ$YYttt3@]jjX]ø]ɁfuEu}tɃᐍ]EDzɃA@]Ɂ]ËUfEf#Jf;uEu}uf;u3@]3]ËUVWWh?EYYM#f;uLQQ$YY~
~)t-EPFV\$$j%jk\WV[YYENDzYFV\$$j%jčEPQQ$ EHEEWV]E_^]ËUE\$E$]ËUuEQQ$]ËUVWWh?EYYM#f;uiQQ$YY~-~au#E]E\$E$sEPFV\$E]E\$$jj?DzWVEYY)EPQQ$MUy
+;|Z+;
=
=~-PQQ$V\$E]E\$=}%V\$E]E\$E$jj|=}&PQQ$gV\$E]EPQQ$FWV](E:V\$YF$\$E]E$QQE$jj$_^]ËUE\$E$]ËUSVEWPQYj_f;EPEYf;ED3Af;u$fEf#E
Kfعfuz3fEfMz	{zFzAfEurfE
ukfEudfEf@fE%;uNjYDfEffEf;u+fE
ffE
f;ufEffEf;ufM]f]_^[ujYE]ËUQVuV#ȉMf;u&u3f9Fuf9Fuf9u@jXu3f9Fuf9Fuf9u33++EfMf~Wj5_f;3FffV_fMYFZFN#3‰UfNfʃttufN3fFfN3fFf3f3fH_^]ËUMVA#f;^uu3f9Auf9Auf9u@]jX]éu3f9Au
f9Auf9u]3f]ËUQVuN#ЉUf;uuf>u3@jXu
f>u3{++EWfEf3]jZf;3ffNAfEZFNj8ZFN#3‰UfN3ff;}ff3fH_^]ËUMVA#f;^uuf9u3@]jX]éu
f9u3]3f]ËUQEjPuu]ËU]JU]FUS]3t  t3@tttVtPK	EEjPY^t
d!tR"[]ËUW}uE!8V詾WYM#^3_]ËUEu3]VW}uĺM#	#W膿W3;_^]ËUQueEPkEYY]%xE%|E%E%E%E%E%E%E%E%E%E%E%E%E%E%E%E%E%E%ıE%ȱE%̱E%бE%ԱE%رE%ܱE%E%E%E%E%E%E%E%E%E%E%E%E%E%E%E%E% E%$E%(E%,E%0E%4E%8E%~B+t3ɅMNB+t3E3ɅF;BB+t3ɅM~B+t3ɅM~B+t3ɅMNB+t3E3Ʌ_F;BB+t3ɅM2~B+t3ɅM~B+t3ɅMNB+t3E3ɅF;BB+t3ɅM~B+t3ɅMy~B+t3ɅMWNB+t3E3Ʌ1F;BB~+t3ɅM~B+t3ɅM~B+t3ɅMNB+t3E3ɅF;BB+t3ɅMl~B+t3ɅMJ~B+t3ɅM(NB+t3E3ɅF;BB+t3ɅM~B+t3ɅM~B+t3ɅMNB+t3E3Ʌk~B+t3ɅMIB~+S3ɅM8M1+t3EqB+t3EqB+t3EIB+t3EUu
+t3EujJF+t3EuLJF띋Uu
+t3Eu JFnEE]3^[]Ë~EE]EEy~EEƆEE}EE.EeEJ}EREE͉E|EEE6E|E$EiEE{EE҃EEzEE;EpEUQMUSVW}3ۃ ;+t3E<	rA+t3E	rA+t3ErA+ut3EEÅB;AA+t3ErA+t3E{rA+t3EYrA+ut3EEÅ+B;AA+t3Er	A	+t3Er
A
+t3ErA+ut3EEÅB;AA+t3E_r
A
+t3E=rA+t3ErA+ut3EEÅB;AA+t3ErA+t3ErA+t3E|rA+ut3EEÅNB;AA+t3E!rA+t3ErA+t3ErA+ut3EEÅB;AA+t3ErA+t3E`rA+t3E>rA+ut3EEÅB;AA+t3ErA+t3ErA+t3ErA+ut3EEÅqj ^+;σQ$EB;AAr+t3ErA+t3ErA+t3ErA+ut3EEÅB;AA+t3ErA+t3E]rA+t3E;rA+ut3EEÅ
B;AA+t3ErA+t3ErA+t3ErA+ut3EEÅnB;AA+t3EArA+t3ErA+t3ErA+ut3EEÅB;AA+t3ErA+t3ErA+t3E^rA+ut3EEÅ0B;AA+t3ErA+t3ErA+t3ErA+ut3EEÅB;AtA+t3ۅÍ]rA+t3ۅÍ]wrA+t3ۅÍ]UZA+t3E33_^[]ËB;At}A+t3EurA+t3EurA+t3EurA+ut3EEÅjB;AAr+t3E<rA+t3ErA+t3ErA+ut3EEÅB;AA+t3ErA+t3E{rA+t3EYrA+ut3EEÅ+B;AA+t3ErA+t3ErA+t3ErA+ut3EEÅB;AA+t3E_rA+t3E=rA+t3ErA+ut3EEÅB;AA+t3ErA+t3ErA+t3E|rA+ut3EEÅNB;AtsA+t3ۅÍ]uZrA+t3ۅÍ]u<rA+t3ۅÍ]uZA+t3EtRA+t3EB;AA+t3EzrA+t3EXrA+t3E6rA+ut3EEÅB;AAr+t3ErA+t3ErA+t3ErA+ut3EEÅhB;AA+t3E;rA+t3ErA+t3ErA+ut3EEÅB;AA+t3ErA+t3EzrA+t3EXrA+ut3EEÅ*B;AA+t3ErA+t3ErA+t3ErA+ut3EEÅB;AA+t3E^rA+t3E<rA+t3ErA+ut3EEÅB;AA+t3ErA+t3ErA+t3E{rA+ut3EEÅMfBf;ApA+t3ۅÍ]OZA+?3E,B;AAr+t3ErA+t3ErA+t3ErA+ut3EEÅ[B;AA+t3E.rA+t3ErA+t3ErA+ut3EEÅB;AA+t3ErA+t3EmrA+t3EKrA+ut3EEÅB;AA+t3ErA+t3ErA+t3ErA+ut3EEÅ~B;AA+t3EQrA+t3E/rA+t3E
rA+ut3EEÅB;AA+t3ErA+t3ErA+t3EnrA+ut3EEÅ@B;AtA+t3ۅÍ]HrA+t3ۅÍ]&rA+t3ۅÍ]ZA+t3ErA+t3ErA+3EiIE+EEBEbEEEEÕEEhEE$EgEɝEuEEȘE*E֡EE)EE7EGEEEEEELEEWVt$L$|$;v; s%F% Fs	D$^_Ë3Ʃu%F% Fs
vs~vftefoNvfo^0foF fon0v00fof:ffof:fGfof:fo 0}vfoNvIfo^0foF fon0v00fof:ffof:fGfof:fo 0}vVfoNvfo^0foF fon0v00fof:ffof:fGfof:fo 0}v|ovfs
vs~vfEtIuу $E$EEEEED$^_ÐD$^_ÐFGD$^_ÍIFGFGD$^_Ð41<9 Q%Ft׃+ʊFGNOu $0E@EHEXElED$^_ÐFGD$^_ÍIFGFGD$^_ÐFGFGFGD$^_tINOurhooNoV o^0of@onPov`o~pOW _0g@oPw`pu r#  ooNO ututuD$^_̋ƃуtf$fofoNfoV fo^0ffOfW f_0fof@fonPfov`fo~pfg@foPfw`fpJut_t!ooNOv  Jut0tuȃtFGIu$ID$^_Í$++Q‹ȃt	FGIut
vHuY`P<*Գ~rbN:N`pΰܰ
,:L^r0|$̺z`F:.Թȹt`LگįfXJ4$ 4@ش&B\r̵޵&2JbzʶԶ .>L\~Ʒз
.@PbrҸ|α.ز̲~lXB0 ڱ@}@|@|}@@%@D+ECEqCDBEXA+dWnOA	AlGRWpO6a'wj5ObFÅm]rLwx,aOMG	 ķ]v+qAOpO]և+DW^
Oor;owLf[MEĀv*cMjVDEs"@0(9A8L7ʸ!A9mG-*+$%|QOz)(BF\GaUFEzfCNItwׄtxMNI{@>K]TKFad4Cz"zOy|I)sO>BqB
7EC)t0ō*M^2mFT
 }jL^6CTv]=D%OcgP0V	AH
FFPB,ɨ=$HܨEye64BlOUᏢWU]O	ɊFiyŜ?Oɝa3K@~OqK
M;rG¸E\\GNˇbo-XCMtY&h~vIsB U[6J[CS[bHNAF"JL
G:7՝5F3+zFO${aύtA^?UX&I}!<OGFV;&OF}P($IZ^9&M[OrWG 35w~s5i+.bi;'~.gC\[bGEրEv+0PoSi)!@'QL.JifrtgHU;aއ-+o.Eцf@"nO :i+00.PRO—-2NfHyu	M7?eEd9Ē^F{w@=TR%9O'HKlqt}
{ҜJ3F̉.|-!CQ7o֩Cmy4[_eOkmM]`g.H	iVFO#A,\V׉#G``
E%6QM\vWNVM.^R
FHsp^QmOpNr-O&oORO%e{HqC,㟽$\E9Ot<&KA>=a-kQG^),=Nk.4qa޼^Ol^\`U;MW.I|Kg+*U6F:(Y;J\FЗ4mc/4*&{-@`ެ)F#Ϋ>/ICVJNztI6FOEг@wiKw^Ҩ\I;%Sjc(=O'>OСFVe\Kz~|Tn9{ŞC
$&;ل.CZ0YctXT9bq^F*O  !:i+00iI~+.ͩ_@^A% xSiMEQ 3߷;`[}N8úGˢ)w]+.DJQ3(9O>ܥ>G2A`tpZdfapHUeі[/tAxC(DW@Xzvi>VMYFDAtKpȞ&Aõ*.7V`Ɔ'":i+00hXt_vJ)v؂تI'9Y:Oh7
e.{ JOe/+dWnOF]K$Lb`wG:J'Ws5i+.b!\_[CP2nD\HC*v
CBg(#4DLe+.b1ъ*Bp2r%9Y:Oh7ա΋!	Hl?<W>OrAGQ`{FL>!OL'`g$$/4EjfqJ1B*)l6ٿMp.лչL@mIh.6]PO,1Dl4L~ɋ@J7<}iFs5i+.b1IkLIC'+I~vph}OUEK}4@VqzeG'{-F4plTI?rF֔hJuAtXJQx;>VfNr@"=3uw-NFEH/дtF5K@~OqF9tRNNgɆ󝚫N_3haO1FIFS2IEt$c^NIe2$53QB`ϝk(ԺCy&|=HF5ꥂG)]/qNnwmjKDWw? jY>4'r`F$<;{dFP0F:̿,LB)隇AxWObDcq#	ۅ>eL:er=mG)fR
IC0hxU*TK
Ix5i+.b^5N$̈cpH|t$HNOiNㄐi3O<zO1I(
W0\"F-V
ևA)F
Wt חb@Z|KJAVgq@L\J7.jxO`OK #@;>VFhP}N<)ѪF	$aOBd-@y#uLKdqkPCU	.4z]bM
I]Ft
Ox_xrd_w~LNdL֬F4Ku@+К#FlHi"k1%B	T
#8ƪd_NM&uf4Lc'wj5Obx8WFTpj7BWGCQl2FiM^eQI+Idʏ[FFFFF F F!FFF0:s*Dw=F`k;Yi+-z1OY
ȿ4<OV%
X$5I?#3:O4j;Yi+-zj;Yi+-zi;Yi+-zv nr=F>FDF[F"FFF0F1F2F3F%F)F*F0:s*Dw=IFy.Y+FGFHF:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/OFFFFU
8r+C+n4@FacH&8FvCj?e~ҦFFF&FFF	FFk!Pi)?
FFF
F
FFFFFPF%FQFFFF@Fʙ^AiXשFh
Mm8gh
z0Gd<O8mxO4yOԒMm8gh
&FEFǝv\Wސy(_FF4F	Z'B>âRX0eu{ڮP9Vu{0ne0E
Kvne
yOܦϫ|xOjIOQnO09$-1.E^*onePone |~|?ne?PE^#1$-?W2$-?W2$-pw~?neg@ne˳j@ne˳j@ne?W2$-~{S^BEy|KDphKΔӳOհrIOC'zO{TxhO{lhO6ǀ_`\`OOrOh7y)
Oh7BTyI6EZ{ْ?i]?9A!8ҏFs%E~2]r?jdN&6u^gO!B>9}Nr*GݓkFN]ͷghhϓgAc*^Z%Ȕ2AeqKW';?B@
J$SQ`Ɔ(œO>1s-O(hHjxOiQD(ߥl+ rˆLmCBUa{Ӱ~C.`1y/DĊYF;aAdƼ403bpc(Jg
Дէ{E]E)ПS-oEH?syYz(y
K@AXGA'qQUAJ
sY!WOZ{*lg(M2(TfC'>|a. 	O;O.K[K8H]҇26 -&{-r:
%wCjW'tVamy!@iaWBVm`ɠI-`:Bn5OC(K鞟^ﯘ=ѕK0:ښL%2J4{[kYs=BMQ!B\[/B{NsASÖ.̆I#t9JDf?kјH"tŻ-Gs?zZAe!`[ǽ6NXX$KiiőԞ(LqmjKH(.~,-Y@o3\.QCpg{LKIs<_z\
LKo(t;sM|@)^vJYӞ~+IzÊChsxDpWJ?,CP0DOAoZ\q"tDk׾TLrTIkE
a`NNe76_I|kHrYM>s:
.jxOˡd:aDX7iii9P5}+EutX(T6QB~ۜC]_#ͼ_Ld=xr|խhG2`?uIp4Bf6חKt3OtaG'"v0
SNwL1"(iv@	YGح+ObC4`[ԄLr?RJ{,AsEOWL"O7v8yOhKKt&1Zs~:6B}Ftr⋪GMv2̤pDʹfD.b[GvtH;
zr\GڙYkH?FA&OA;,Ui6
IJ"x9J4ܵ;EfDװqmrE.1!YuY&HxHϣ'GVBeUNOخ|)IE@0lyדسDg,ݠeL3"5/QqCAwSk5X;-3B{_41lxpOh6ǾƱLb
VBPoz5zD #D@Fgm[M/BT|\?@zpDF[0	49Z
I}AaB}KX䌠%D|DZ#`ڽWvGE>ςZ#@k{X8&oIQd5CvSdn0@DH&'E4VwҁnB*O&-bfMlV!j

hFXapf_:qJ?򥸿2cpF^W5}3ƔHjiOY<0G==
6eFpqFwHҶe_K#q}kdO-pV+UN;;z5Og5е.Í}DwMm3sG%`4n.8E40yvF'6я]A.VGމJ=PpZd1FOЊĽFK6eJ7`, :i+00Fh3MnMܙS{5)xKt	O3CKsw`$D&l;0MHֿRUBu(dT&arrCuƋ.|uU:WPHw[ێ	Z܊M`* !sG3^F0MJSkyZ
8y
M3,/KqI\M;TQ'CHCh4-6C$/`zLbeLWwR"F)JȬ
պFD-ʀr33yHȅF/_~_INK
R(N伽I@܏Uo#RHkM?'kaIõ}EFVxCEg{Sl"vM`3)/#RW$ZI/Փg3wB$hŨ"IΕL?vk΄e}IƼ8-F"DDm'Cb**+C,R[09|)J=AxB:RC%jAyiȳO^7q2hK_Lrz=*Fŗ5WIZgnMI/~o&
IFk"t% 0H Ng4f/`CU7%(Lx#h>5qM?w;E9eZJ	57BxsCU3FFXElEEEadvapi32api-ms-win-core-fibers-l1-1-1api-ms-win-core-synch-l1-2-0kernel32EventRegisterEventSetInformationEventUnregisterEventWriteTransferFlsAllocFlsFreeFlsGetValueFlsSetValueInitializeCriticalSectionExPE\EdEpE|EEEEEEEEEZFEEEEEEEEEEE E$E(E,E0E4E8E><<!==!=[]operator->*++---+&->*/%<<=>>=,()~^|&&||*=+=-=/=%=>>=<<=&=|=^=`vftable'`vbtable'`vcall'`typeof'`local static guard'`string'`vbase destructor'`vector deleting destructor'`default constructor closure'`scalar deleting destructor'`vector constructor iterator'`vector destructor iterator'`vector vbase constructor iterator'`virtual displacement map'`eh vector constructor iterator'`eh vector destructor iterator'`eh vector vbase constructor iterator'`copy constructor closure'`udt returning'`EH`RTTI`local vftable'`local vftable constructor closure' new[] delete[]`omni callsig'`placement delete closure'`placement delete[] closure'`managed vector constructor iterator'`managed vector destructor iterator'`eh vector copy constructor iterator'`eh vector vbase copy constructor iterator'`dynamic initializer for '`dynamic atexit destructor for '`vector copy constructor iterator'`vector vbase copy constructor iterator'`managed vector copy constructor iterator'`local static thread guard'operator ""  Type Descriptor' Base Class Descriptor at ( Base Class Array' Class Hierarchy Descriptor' Complete Object Locator'CV: ::template-parameter-generic-type-`'`anonymous namespace'''`non-type-template-parametervoid`template-parameter...NULL%d`template-type-parameter-`generic-class-parameter-`generic-method-parameter-}' }' `vtordispex{`vtordisp{`adjustor{`local static destructor helper'`template static data member constructor helper'`template static data member destructor helper'static virtual private: protected: public: [thunk]:extern "C" ) char short int long unsigned void volatilestd::nullptr_t std::nullptr_t,..., throw(cpuamp, charshortintlongfloatdoublebool__int8__int16__int32__int64__int128char16_tchar32_twchar_t__w64 UNKNOWNsigned const volatile`unknown ecsu'union struct class coclass cointerface enum volatile const & && cli::array<cli::pin_ptr<)[{flat}{for s Fi@i@i@\F@@@F$@B@h@F@@
@@F@@@F@@$@ ?? EEE50P( 8PX700WP  `h````xpxxxxEEE00P('8PW700PP (`h`hhhxwpwpp(null)(null)
		


!
5A
CPR
S
WYl
m pr	

	
)

Tc-^k@tFМ,a\)cd4҇f;lDِe,BbE"&'O@V$gmsmrd'c%{pk>_njf29.EZ%qVJ.C|!@ΊĄ'|Ô%I@T̿aYܫ\DgR)`*!VG6K]_܀
@َЀk#cd8L2WBJa"=UD~ $s%rс@b;zO]3AOmm!3VV%(w;I-G 8NhU]i<$qE}A'JnWb쪉"f37>,ެdNj5jVg@;*xh2kůid&_U JW
{,Ji)Ǫv6UړǚK%v
	t:H孎cY˗i&>r䴆["93uzKG-wn@_l%Bɝs|-Ciu+-,W@zbjUUYԾX1EL9MLy;-"m^8{yrvxyN\lo};obwQ4Y+XW߯_w[R/=OB
R	E]B.4o?nz(wKgg;ɭVlH[=J6RMq!	EJjت|Lu<@rd6x)Q9%0+L;<(wXC=sF|bt!ۮ.P9B4Ҁy7P,=87MsgmQĢR:#שsDp:RRN/M׫
Ob{!@fu)/wdq=v/}fL3.
iLs&`@<
q!-7ڊ1BALlȸ|Rabڇ3ah𔽚j-6zƞ)
?IϦw#[/r5D¨N2Lɭ3v2!L.2>p6\BF8҇i>o@@w,=q/	cQrFZ**F΍$'#+GK	ŎQ1VÎX/4Bycg6fvPbag
;s?.❲ac*&pa%¹u!,`j;҉s}`+i7$fnIoۍut^6n16B(Ȏy$dAՙ,C瀢.=k=yICyJ"pפldNnEtTWtøBncW[5laQۺNPqc+/ޝ"^̯p?m-}oi^,dH94X<H'W&|.ڋu;-Hm~$P	
%-5	>
H
R]iu
-C	Y	p	



	%
d'@Bʚ;minkernel\crts\ucrt\inc\corecrt_internal_strtox.h__crt_strtox::floating_point_value::as_double_is_double__crt_strtox::floating_point_value::as_float!_is_doubleINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanINFinfINITYinityNANnanSNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)SNAN)snan)IND)ind)Visual C++ CRT: Not enough memory to complete call to strerror.Visual C++ CRT: Not enough memory to complete call to strerror..exe.cmd.bat.com./\?*	Runtime Error!

Program: <program name unknown>...

Microsoft Visual C++ Runtime LibraryF\F\/ F/mscoree.dllCorExitProcessFlCFFlCFF4DFFDFF{DFFDLC_ALLLC_COLLATELC_CTYPELC_MONETARYLC_NUMERICLC_TIME	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~=;;=C_.,_.CLC3CCFCICCCDDCsCCtCC*B*B~D	CC;C>CC8C\\\.\.TMPTMPmsvcrt.dllccsUTF-8UTF-16LEUNICODEccsUTF-8UTF-16LEUNICODEF`FlEFF FFFEFHFFFFhFF	FXEEX	Fapi-ms-win-appmodel-runtime-l1-1-1api-ms-win-core-datetime-l1-1-1api-ms-win-core-file-l2-1-1api-ms-win-core-localization-l1-2-1api-ms-win-core-localization-obsolete-l1-2-0api-ms-win-core-processthreads-l1-1-2api-ms-win-core-string-l1-1-0api-ms-win-core-sysinfo-l1-2-1api-ms-win-core-winrt-l1-1-0api-ms-win-core-xstate-l2-1-0api-ms-win-rtcore-ntuser-window-l1-1-0api-ms-win-security-systemfunctions-l1-1-0ext-ms-win-kernel32-package-current-l1-1-0ext-ms-win-ntuser-dialogbox-l1-1-0ext-ms-win-ntuser-windowstation-l1-1-0user32AreFileApisANSICompareStringExEnumSystemLocalesExGetActiveWindowGetCurrentPackageIdGetDateFormatExGetEnabledXStateFeaturesGetFileInformationByHandleExGetLastActivePopupGetLocaleInfoExGetProcessWindowStation	GetSystemTimePreciseAsFileTimeGetTimeFormatExGetUserDefaultLocaleNameGetUserObjectInformationWGetXStateFeaturesMaskIsValidLocaleNameLCMapStringExLCIDToLocaleNameLocaleNameToLCIDLocateXStateFeatureMessageBoxAMessageBoxW
RoInitialize
RoUninitializeSetThreadStackGuarantee
SystemFunction036am/pma/p -
:	+%SunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssSunMonTueWedThuFriSatSundayMondayTuesdayWednesdayThursdayFridaySaturdayJanFebMarAprMayJunJulAugSepOctNovDecJanuaryFebruaryMarchAprilJuneJulyAugustSeptemberOctoberNovemberDecemberAMPMMM/dd/yydddd, MMMM dd, yyyyHH:mm:ssen-USFFFFFFFFFFFFF
F
F
F
F
F
F 
F$
F(
F,
F0
F4
F8
F<
FD
FP
FX
F
F`
Fh
Fp
Fx
F
F
F
F
F
F
F
F
F
F
F
F
F
FFFF F0F@FTFhFxFFFFFFFFFFFFFFFFFF(F4F@FPFdFtFFFFFFFFINFinfNANnanNAN(SNAN)nan(snan)NAN(IND)nan(ind)e+000         (((((                  H      (                          0         (((((                  H 	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~SunMonTueWedThuFriSatJanFebMarAprMayJunJulAugSepOctNovDecTZFFFFF$F8FTFhF|FFFFFFFFF(F8FHFXFhF|FFFFFFFF$F4F@FPFFdFFFFFFFFNo errorOperation not permittedNo such file or directoryNo such processInterrupted function callInput/output errorNo such device or addressArg list too longExec format errorBad file descriptorNo child processesResource temporarily unavailableNot enough spacePermission deniedBad addressUnknown errorResource deviceFile existsImproper linkNo such deviceNot a directoryIs a directoryInvalid argumentToo many open files in systemToo many open filesInappropriate I/O control operationFile too largeNo space left on deviceInvalid seekRead-only file systemToo many linksBroken pipeDomain errorResult too largeResource deadlock avoidedFilename too longNo locks availableFunction not implementedDirectory not emptyIllegal byte sequence+FFF(Fja-JPzh-CNko-KRzh-TWamericanamerican englishamerican-englishaustralianbelgiancanadianchhchichinesechinese-hongkongchinese-simplifiedchinese-singaporechinese-traditionaldutch-belgianenglish-americanenglish-ausenglish-belizeenglish-canenglish-caribbeanenglish-ireenglish-jamaicaenglish-nzenglish-south africaenglish-trinidad y tobagoenglish-ukenglish-usenglish-usafrench-belgianfrench-canadianfrench-luxembourgfrench-swissgerman-austriangerman-lichtensteingerman-luxembourggerman-swissirish-englishitalian-swissnorwegiannorwegian-bokmalnorwegian-nynorskportuguese-brazilianspanish-argentinaspanish-boliviaspanish-chilespanish-colombiaspanish-costa ricaspanish-dominican republicspanish-ecuadorspanish-el salvadorspanish-guatemalaspanish-hondurasspanish-mexicanspanish-modernspanish-nicaraguaspanish-panamaspanish-paraguayspanish-peruspanish-puerto ricospanish-uruguayspanish-venezuelaswedish-finlandswissukususaamericabritainchinaczechenglandgreat britainhollandhong-kongnew-zealandnzpr chinapr-chinapuerto-ricoslovaksouth africasouth koreasouth-africasouth-koreatrinidad & tobagounited-kingdomunited-states4FENUHFENUlFENUFENAFNLBFENCFZHHFZHIFCHSFZHHFCHS8FZHI\FCHTFNLBFENUFENAFENLFENC FENB8 FENIP FENJp FENZ FENS FENT FENG!FENU!FENU0!FFRBP!FFRCp!FFRL!FFRS!FDEA!FDEC!FDEL"FDES8"FENIT"FITSp"FNOR"FNOR"FNON"FPTB"FESS#FESB<#FESLX#FESO|#FESC#FESD#FESF#FESE$$FESGH$FESHl$FESM$FESN$FESI$FESA$FESZ%FESR0%FESUX%FESYx%FESV%FSVF%FDES%FENG%FENU%FENUA%FUSA%FGBR&FCHN&FCZE&FGBR(&FGBRD&FNLDT&FHKGh&FNZL&FNZL&FCHN&FCHN&FPRI&FSVK&FZAF&FKOR'FZAF('FKOR@'FTTO%FGBRd'FGBR'FUSA%FUSAACPOCP6-3F3F 3F(3F83F@3FH3FP3F	X3F
`3Fh3Fp3F
x3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F3F4F 4F!4F"%F#4F$ 4F%(4F&04F'84F)@4F*H4F+P4F,X4F-`4F/h4F6p4F7x4F84F94F>4F?4F@4FA4FC4FD4FF4FG4FI4FJ4FK4FN4FO4FP4FV5FW5FZ5Fe5F 5F$5F05F<5F(FH5FT5F`5Fl5F	Fx5F5F
5F5F5F5FFF5F5F5F5F5F5F6F6F 6F,6F86FD6F P6F!\6F"h6F#t6F$6F%6F&6F'6F)6F*6F+6F,6F-6F/6F27F47F57F6(7F747F8@7F9L7F:X7F;d7F>p7F?|7F@7FA7FC7FD7FE7FF7FG7FI7FJ7FK8FL8FN8FO$8FP08FR<8FVH8FWT8FZd8Fet8Fk8Fl8F8F8FF8F	8F
8F8F8F8F9F9F9F09F,<9F;T9F>`9FCl9Fk9F9F9F9F	9F
9F9F9F;9Fk:F:F:F(:F	4:F
@:FL:FX:F;d:Ft:F:F:F	:F
:F:F:F;:F:F	:F
:F;F;F;,;F<;F	H;F
T;F`;F;x;F ;F	 ;F
 ;F; ;F$;F	$;F
$;F;$;F(;F	(;F
(GF4F7HFx3FHFN4F/HFt3F$HF0HFZ3F
@@ IqI`B
`BYnYnloglog10exppowasinacossqrt??
|?Q-8>=޶W?0	k8=ޮp?x9=>.ښ?pn5=Yح?	Q*=c??b6=Y?T?=>?W!=@-32?Dz=p(?vP(=`?US?>=e?g7=`ŀ'?bͬ/=^s?}#=Jwk?zn=Nָ?LN9=@$"3?5Wg4p6=T?Nv$^)=&?.)<lB?M%=`j?w*= <śm?E2=ެ>
?E=t??=OQ?w(@	<0?Ac
0=Pyp?dry?=St)?4K	>=$?QhBC .=0	ub?-0=?a>-?=?Й,<(lX ?T@b ==P?3h,%=f??# =V?ߠϡ6=Y?z $=G? $l35=@n?[+3=Rŷ?sdLi==p|?rx"#2=@.?|U2=lԝ?rF=a?4=Y?sl׼#{ =`~R=?.i1=,? =vX?=p?h}s"=	E[
?%S#[k=7H?j=!V1?}a2=jq?20J5=?5=x¾/@?"B <1=iz?\-!y!=X0z?~b>==:?#.X'=HBO&?(~=xbb?.=Cq?y7i9+=v?:=0?2ض8=xPD?X1=??Q?Q?????????]?]?P?P? ? ?U?U?(?(?`?`?_?_?????z?z?1?1?p?p???(e?(e?@#?@#???`?`?hk?hk?,?,?x?x?????N?N?x?x?p?p???~?~?HN?HN???????p?p?Xi?Xi???????????8?8?s?s?pI?pI?&?&?????o?o? *? *???`?`?Z?Z???0?0???PY?PY???`?`???pm?pm?/?/??????tanhatanatan2sincostanceilfloorfabsmodfldexp_cabs_hypotfmodfrexp_y0_y1_yn_logb_nextafterOFOFOFOFYFYF!8XFOF
OF@XFHXFOFPXFTXF XXF\XFdXFlXFtXF|XFXFXFXFXF"XF#XF$XF%XF&XFsinhcosh????؛FiECreateDirectory (%s)CreateFile (%s)CreateFileMapping (%s)MapViewOfFile (%s)1.2.8inflateInit2 returns %dinflate returns %dinflateEnd returns %d\-32PURELIBPLATLIBHEADERSSCRIPTSScripts\DATALib\site-packages\Installation failed.import py_compile; py_compile.compile (r'%s')%s%cPy_InitializePy_SetProgramNamePy_FinalizePyRun_SimpleStringPySys_GetObjectPy_OptimizeFlagCSIDL_COMMON_STARTMENUCSIDL_STARTMENUCSIDL_APPDATACSIDL_COMMON_DESKTOPDIRECTORYCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_STARTUPCSIDL_STARTUPCSIDL_COMMON_PROGRAMSCSIDL_PROGRAMSCSIDL_FONTSsshell32.dllfunction not availableSHGetSpecialFolderPathAno such folder (%s)unknown CSIDL (%s)CoInitialize failed, error 0x%xsss|sssiCoCreateInstance failed, error 0x%xQueryInterface(IPersistFile) error 0x%xSetPath() failed, error 0x%xSetDescription() failed, error 0x%xSetArguments() error 0x%xSetIconLocation() error 0x%xSetWorkingDirectory() error 0x%xFailed to create shortcut '%s' - error 0x%xssiicreate_shortcutget_special_folder_pathget_root_hkeyfile_createddirectory_createdmessage_boxPYTHONHOME=%sSOFTWARE\Python\PythonCore\%d.%d%s\InstallPathPyImport_ImportModulePyObject_SetAttrStringPyObject_GetAttrStringPyCFunction_NewPy_BuildValuePyArg_ParseTuplePyErr_FormatPyLong_FromVoidPtrbuiltinsValueErrorOSErrorPySys_SetArgvCould not open postinstall-script %s
Running Script...*** Could not load Python ***PyErr_PrintCan't load Python for pre-install script (%d)Running the pre-installation script failed
Out of memory!Runtime Error100 Made Dir: %s
200 File Copy: %s
200 File Overwrite: %s
.pyErrorInvalid cfgdata magic number (see bdist_wininst.py)~duCould not create temporary fileTimes RomanSetupWindowClassSetup.exeCould not register window classSetup %sThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCorePython Version %s (found in registry)Software\Python\PythonCore\%s\InstallPathStrangeDon't know Python's installation typePython %s is required for this package. Select installation to use:Python version %s required, which was not found in the registry.No Python installation found in the registry.Cannot installPython Version %d.%dpython%d%d.dllHKEY_LOCAL_MACHINEHKEY_CURRENT_USERYou do not seem to have sufficient access rights
on this machine to install this softwareCould not open key%s\%s-wininst.logaCan't create "%s" (%s).

Try to execute the installer as administrator.*** Installation started %Y/%m/%d %H:%M ***
Source: %s
999 Root Key: %s
%s-py%d.%dCould not create key020 Reg DB Key: [%s]%s
Python %d.%d %sDisplayNameCould not set key value040 Reg DB Value: [%s\%s]%s=%s
%s\Remove%s.exewb"%s\Remove%s.exe" -u "%s\%s-wininst.log"UninstallString*** Installation finished %Y/%m/%d %H:%M ***
Click Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Ready to installRunning pre-installation scriptInstalling files...Failed to unzip installation filesCompiling files to .pyc...Loading python...Compiling files to .pyo...-installPlease wait while running postinstall script...\Scripts\300 Run Script: [%s]%s
*** run_installscript: internal error 0x%X ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.IsUserAnAdminrunasFailed to start elevated process (ShellExecute returned %d)Setuptitleinfobuild_infotarget_compiletarget_optimizetarget_versionnamemetadatainstall_scriptuser_access_controlforceautononeoopsBad user_access_control value%s.batw:Repeat
del "%s"
if exist "%s" goto Repeat
Could not delete keyCould not delete value-remove*** Could not run installation script ***uninstall-scriptWrong number of args-u2. arg is not -urcould not open logfileOut of memoryPlease confirmAre you sure you want to remove
this package from your computer?%d Root Key: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Made Dir: %s%d File Copy: %s%d File Overwrite: %s%d Reg DB Key: %s%d Reg DB Value: %s%d Run Script: %s%d files and %d directories removed
%d files or directories could not be removed%d files and %d directories removedUninstall Finished!Could not open archiveRemoveThis program is normally started by windowsSetup program invalid or damagedZFFFZFFFF$F8FHFZF0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfa`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

@@HN	

#+3;CScs	
!1Aa 0@` inflate 1.2.8 Copyright 1995-2013 Mark Adler invalid distance too far backinvalid distance codeinvalid literal/length codeincorrect header checkunknown compression methodinvalid window sizeunknown header flags setheader crc mismatchinvalid block typeinvalid stored block lengthstoo many length or distance symbolsinvalid code lengths setinvalid bit length repeatinvalid code -- missing end-of-blockinvalid literal/lengths setinvalid distances setincorrect data checkincorrect length checkneed dictionarystream endfile errorstream errordata errorinsufficient memorybuffer errorincompatible version*PXT,,*PX*PX
\F FвEF(F8F@FF@(FFpFFF@FF@pF0FF̚FؚF@F0F@FHFFF$F@FHF@FdFTFdFpF@FdF@TFFFFF@FF@FFFFFF@F`RSDS7H~H,E:\CPython\cpython35\lib\distutils\command\wininst-14.0.pdbGCTL.text$mn.idata$5в.00cfgԲ.CRT$XCAز.CRT$XCAAܲ.CRT$XCZ.CRT$XIA.CRT$XIAA.CRT$XIAC.CRT$XIC.CRT$XIZ.CRT$XPA.CRT$XPX.CRT$XPXA.CRT$XPZ.CRT$XTA.CRT$XTZ .rdata.rdata$r .rdata$sxdata,D.rdata$zzzdbgp.rtc$IAAt.rtc$IZZx.rtc$TAA|.rtc$TZZ.xdata$x<.idata$2ȫ.idata$3ܫ.idata$4.idata$6.data.data$r0.bss.gfids$x.gfids$y0.rsrc$010(.rsrc$02~@~@2@E@|@|v@@@1AAA$AA1AAAA,B,B-B^B^BB2C2C2C53CgCgCgC$kCxCxC?rClCYmClCmCfCCUCYCCfC̘C|CPCCCgC[CCSCC7C
CC&C2CCC*+D,D/DM1D8DCODODNDQDESDdDbD`DDyDDгD0DκDD׵DDDDQDDTDDDfD
DDD"DE/E/ES:E9EE1E1EyhEhEڮ(4X0BTʳ4ܫn(Lδ`P<*Գ~rbN:N`pΰܰ
,:L^r0|$̺z`F:.Թȹt`LگįfXJ4$ 4@ش&B\r̵޵&2JbzʶԶ .>L\~Ʒз
.@PbrҸ|α.ز̲~lXB0 ڱPropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrorSetFileTime
lstrlenAUnmapViewOfFilePGetLastError0GetFileAttributesACreateFileACloseHandleCreateFileMappingACreateDirectoryADosDateTimeToFileTimeMapViewOfFilePReadFilebGetModuleFileNameASetPriorityClass	GetCurrentProcessGetStdHandleLoadLibraryExAcGetModuleFileNameW5SetThreadPrioritySetFilePointerResumeThreaddGetModuleHandleAMultiByteToWideCharGetTempPathA
GetCurrentThreadLoadLibraryADeleteFileA"SetStdHandleGetProcAddressLocalFree;GetFileSizeRemoveDirectoryAFreeLibraryCreateProcessAFormatMessageAGetTempFileNameAGetPrivateProfileIntAGetPrivateProfileStringAKERNEL32.dllEndPaintBeginPaintReleaseDCWUpdateWindowzGetParentkPeekMessageA<GetDlgItemSetCursorSendMessageASetDlgItemTextASendDlgItemMessageA?TranslateMessagepCreateWindowExADefWindowProcARegisterClassASMoveWindowFMessageBoxA ShowWindowzwsprintfAGetSystemMetricsoPostMessageA4GetDCLoadCursorABGetFocusGetWindowRectDispatchMessageAUSER32.dllVCreateSolidBrushDeleteObjectSetBkModeTextOutASetTextColor7CreateDIBitmapSelectObject=CreateFontAGDI32.dllrRegEnumKeyExAkRegDeleteValueARegOpenKeyExARegSetValueExARegQueryValueA\RegCreateKeyExARegQueryValueExAaRegDeleteKeyATRegCloseKeyADVAPI32.dll3ShellExecuteASHELL32.dllOCoInitializeCoUninitializeCoCreateInstanceole32.dllUnhandledExceptionFilterCSetUnhandledExceptionFilteraTerminateProcessmIsProcessorFeaturePresent-QueryPerformanceCounter
GetCurrentProcessIdGetCurrentThreadIdGetSystemTimeAsFileTimeKInitializeSListHeadgIsDebuggerPresentGetStartupInfoWgGetModuleHandleWWInterlockedPushEntrySListTInterlockedFlushSListRtlUnwind%EnterCriticalSectionLeaveCriticalSectionDeleteCriticalSectionHInitializeCriticalSectionAndSpinCountsTlsAllocuTlsGetValuevTlsSetValuetTlsFreeLoadLibraryExWWideCharToMultiByteGetCommandLineAGetCommandLineWCreateFileWGetDriveTypeW>GetFileTypePeekNamedPipe^SystemTimeToTzSpecificLocalTime]FileTimeToSystemTimeWriteFileQExitProcessfGetModuleHandleExWGetACPGetConsoleModeNReadConsoleW3HeapFree/HeapAllocGetDateFormatWGetTimeFormatWCompareStringWLCMapStringWTGetLocaleInfoWtIsValidLocaleGetUserDefaultLCIDGEnumSystemLocalesWSetEnvironmentVariableASetEnvironmentVariableW6HeapReAllocGetConsoleCPGetStringTypeWGetTimeZoneInformationSetCurrentDirectoryWGetCurrentDirectoryWIGetFullPathNameWFGetFullPathNameAOutputDebugStringAOutputDebugStringWWaitForSingleObjectExCreateThreadhFindClosemFindFirstFileExAnFindFirstFileExW}FindNextFileAFindNextFileWrIsValidCodePageGetOEMCPGetCPInfo'GetEnvironmentStringsWFreeEnvironmentStringsWGetProcessHeapSetConsoleCtrlHandler2GetFileAttributesExWSetEndOfFileSetFilePointerExFlushFileBuffersWriteConsoleW8HeapSizeGetTempPathW!EncodePointerDecodePointer@RaiseExceptionDN@    F


FFFFFFF@FFF@FFCFFPSTPDTFPF`y!@~ڣ @ڣ AϢ[@~QQ^ _j21~                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZF..FFFFFFFFFFFFFFFFFFFuZF([FZF([F[FZF[F[F [FZF[F\F\F(\FH\F`\Fx\F\F\F\FSoftware\Microsoft\Windows\CurrentVersion\UninstallSoftware\Microsoft\Windows\CurrentVersion\Uninstallt^F@^Fc@^FL@^F@^F*@^F@ZFZFZFZF[FZF[F[F [FZFDZF.?AVDNameNode@@DZF.?AVcharNode@@DZF.?AVpcharNode@@DZF.?AVpDNameNode@@DZF.?AVDNameStatusNode@@DZF.?AVpairNode@@DZF.?AVtype_info@@bb{4ll8>;	~**tsIF3LXllWmomWmomq	jT%@+&UBC

Er4

Yhgflkjponutsyxw 8nhklmn 0
8Z@!(n,	BBB999111)))cR[RABZRYRZRAB[R[RAB[RAAB[ && &&&@JQ1AA1ZQ1111ZQ1AAZ@JQ1AAZQ1AAJ eu eu @ABZ@J@G@F@F@G@AABX@J@AABX@J@J@AA1X@J@G@HRX@G@AAG@ZRX@AAG@JQJed%ed%ed@AA1ZQ1AA1X@J@HQ1AA1X@1A1ZQ1AA1ZQ1A1J  & & RAABZRABZR[R[RABZRYRBZRABZRBW@J@J &R[R[R[R[R[RABZR[R[R[ & & & & & & &@J@J@J@J@HQ1AA1X@J@J@J@J@J@J@G@J@G@JQJ@ABZQ11Z@J@AAG@J@G@GQ1J@AA1ZQ1YQ1[@J@AAG@J@G@1W@J&@I@G@J@J@J@J@G@J@G@Z@J@AA1X@J@HRABX@J@HQ1AA1X@J@J  &  %& & & &RAABZR[RZRAAABZR[R[RABZR[R[@H{SetupMS Sans SerifP}
This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.P}PhnP}@H{SetupMS Sans SerifP}
Select python installation to use:PP}7Python Directory:P}jPhnPP}BInstallation Directory:@B2Find other ...@H{SetupMS Sans SerifP}
Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.P}msctls_progress32Progress1P}Installation progress:Phn@H{SetupMS Sans SerifP}
Click the Finish button to exit the Setup wizard.PhnP}(@D0U0c000001B1W1111111111:2^2r222222333x4|555L7f7m7t7}7777777
88=8D8g8n888888#9G9R9Z9d9o9z99999:::3:<:R:X:m:x:::::::::::::::;";(;3;B;T;c;i;o;;;;;;<$<>>/>6><>B>N>T>d>q>|>>>>>>>>>*?f?????????? 0+03090C0H0k0s0{00000000000111111'2222"3)3P3b33333333333#4]4g44444445B5j5555555!6C6Y6{6666677-7>7L7e7r7y77777788.8>8D8[8h8w8888888888889:9O9x99999999-:7:F:Z:{::::::::::;;$;+;6;];i;;;;;;;;;;;<<<7<>6>L>W>>>>>>?%?D?p???????0000$0.080>0E0[00001(1-161A1H1^1c1u1111111111111222,232G2U2Z2k2w22222222222333P333333444)40464<4N4a4f4p4u44444
5(52575=5H5N5Y5e5j5o5555555556
686D6N6f6r6w6}66666666667"7-7M7R7X777778M8Z8p8888888899!91979D9W9\9p99999999:#:0:8:E:P:m:s:|::::::	;;);9;?;G;h;m;;;;;;	<1<6>>>#>4>?>K>S>Z>w>>>>>>>>>>>?,?2?@?G?L?Z?f?q?v???????????????????@000
000!0&0/040<0A0R0Y0`00000000001111#1|1111111K2^2h2z22222&3,373>3E3Q3a3h3o3x3333444'4.454>4w4444+5?5c5j5q5556676!757?7D7\7e7778%8+8F888889@9}9999999::3:>:D:K:U:_:d:::::::>=>w>~>>>>>>>>>>??"?.?8?R?Y?e?o?????????P0000R0Y0e0o0001!1-171Q1X1d1n11111111111	22-242@2M2j2q2}222222223
3/33I8X8d899::<>>>0?H?\?o?001W1j1}1111111122l2y2222222,3G3S3b3k3x333333.474=4n4585B5S5y5555&6/646Z6_6666667$7777888P8Y8f8q8z888889;;;>>m???4P011(2s22222393G3M3h333333334464[4b4k4y4444444444p5u5z5555555555555555666&6+606@6E6J6666667*7F7U7a7o7777778
88H8M8R8888888999?9H9M9R9v99999999999:3:;:@:P:Z:::::::::::h;<$>0>6>>>E>N>W>\>d>j>>>>>>0??t0000011+1G1N1a1n1111111d3s3344T5b555667777C9v99/:P:o::f;;;3}>???00T112D2W22222222333*3e3333333474b4}444444 5O5t5y55555555556P6k678'8`8y8888889999T99999999:.:Y:c:m:w:::::;$;1;;;;< <-u>>>1?7?a???f00001111123334404;44444445M5z55555e6y66666 7778-8:8}888889"9)909|99999999:	:-:s:w:{::::::::;K;b;;;;;<<<<"0>G>Q>x>??0'0Z01!2?2b2q22222333+4h44445-5D55555556`777777788'8J8Z8j88888,9H9M9a9999::M:`:j:|:::::::	;;>;O;~;;;<==(=F={=====C>[>d>z>>>7?f???0U0p0001/1E11132J2w22223334444444
5a5555566k6p6666667'7G7g777778!8:8S8]8t8T9Y9y99:::=;T;u;;;;;;;;;;<@<<<<<<=!=8=]=====>Y>q>>??070G0000000000000041f1r11122f2q222222
33K3W3h3333333!4Q4c44444#5,686C6O6V6[6a6f6l6q6v6|666666\7777777788$8*808Y88A9M9999:M:Y:_:::v<7=????????h00=0R0h0u0000011S2222D3t3}334+4O4z467D77778N89
:*:J:n:z:a;j;r;>>>>?'?`? P222C333Q9:R<>? Q1`D=12
334599:$:D:V:v::::::;);K;`;;;;;;<$<6<p2222222222227g8k8o8s8w8{888#999999999V:::::::::r;<<<<<<<#<>>>>>>>?????????dl011111#1'1+11/23272;2?2C2G2K22_3c3g3k3o3s3w3{3444444444S5555555553s57<:<?L3333333443474;4?4C4G4K4O4S4W4[4_4)556n66P77/888t99$<V>>>+?E???080001 11112455
61676=6C6I6O6U6[6a6g6m6s67,88z9!:: @5755666J7}77`88:::::::::::;=;O;<=00
1=1P1P@8<.>/>S>>`=24]55S66I77?8 >>F>N>>>??????lS0\0001#1-252H3Q3t4}4555556=6F6{66666617:7p7D8H8L8P8T8X8\8`8d8h88H9L9P9T9X9\9`9d9h9l97Y899::D=,01c1h1m111179:=:D:|=??B?I? 255559::;;>c>?l<444448<======== =$=3=t=x=|===============>>>>>\>`>d>h>l>p>t>x>|>> (555555555555>?c??0D002T222\4r4!575556678R8"9[99~::
;;>?@P	040R0c11113c33345J5n55556&6n688I99W:C;V;<<<
=f>t>>PQ122222I3x333333333444*4Y4|44444455-595A5Y5~55555a6j6666	777777778%;6;<
<<<<<<<<	===8=>=H=g=n======`001K1h1182P2x2222223
3333333333333344&4f4o44444,555y55556%606F6Y6l666667717G7^7e7q77777788.8@88888888$9_9j9|99993:@::::e;;;;X<<< =pXI00000000112	22)2t22!3A44445/7V888:;;;;<6<?52m222333333333
4'4x45/555H6S666
777k8888
999+9M9`999999999999:>:C:c:h::;!;0;M;o;(=D>>>>??? ????????001#1S111#2a2y7Y88	999p::<;7<>b01P4[4n4x44445{5555676]677778`89;9^9k9v99:9:D:O::::!;4;j;v;;>?)?X?o??????|90U000*1192x2222!3^3h3333333333
44=4C4U444p55566999/:;';4;g;s;{;;;;;d:0e0001t2222v336666677C7J7P7W7i7n7777,8G8L8R8X8j8p8888888888888889999+90959E9J9O9_9d9i9y9~999999999999999:::::/:4:9:I:N:S:c:h:m:}::::::::::::::::;	;;;#;3;8;=;M;R;W;g;l;q;;;;;;;;;;;;;;;;4<<U>r>}>>>>>>>>??4???D?I?d?n???????????D0090D0I0N0{0000000
1111C1O1m1x1}1111111122-282=2B2l22222222333373[3f3k3p333333334 4+40454Y444444455"5'5E5n55555"6F6Q6V6[6v6666666666787C7H7M7h777777778848?8L8b8m8r8w88888899&9+909R9`9o99999999: :%:3:n;;;F<=O====>>T>w>>>?X1568888888899v999999::":*::E;;;;;'<5<=r>.????40501"1224|44566666666$8O::;<<=>> L36777.757M7T7r7|999-::;
<<<=<^<<<<<<6=H=N=>A>>?0|[000001111111,222373B3R334454?4^4|445=5[556+6G666/7K7~777<8889999<<==B>>>>>>@+070F0Q0U0]0c0i0o0000g11224-466666667
777*727D7O7W7_7g7p7y777778W8b8889%9I9R9w9|9999999999::;;<<<<<<<<<<="=G=O======|>>>>>??PX00N1U1|1202V223364D44466A7q7{777/8,96999F:T:::; ;<==!>+>>>`0!0a0p0~0000001:1A1111111192F2u222233[3o3333G4R4^444)5366"8)8888z::::::;S;e;;;;;;)=;= ?p|$222[333n44585w55557`7f7-8@89:::::::
;;$;W;^;e;l;;;;;;;>>>>>??G?\?j?s???T070m001F1m115556:6`66666=8=9;;;4c>J??P023	444566v77C8L8o888\9e999K:;R>>P?X???0[0j0001111111!2L2n22222222;3M3i33333344=4O4W4u4444595A5W5u555555)60676>6|66677877|88888
9@999999H:R:X:b:r::=247H881c1335`59{99:;$;;;
l>>>?N?k??T090Y00Q111111$2J2z2223C3l333v55C67+7777778889,9j9f;U?? /0)1}2::S:Z:=y>>>>1X66>>>>0223;3B3G69999h;p;==}>w???? L3344536'71777E8a888889^9;<>>>>>:?Y?r?}???0D0f0x000T14
5"515D5\5k5586~68)9:{:::::`<==>2>>@"0b0000$1H1S1`1r111W2l2u2~222222
3@3i333334	44474?4444444@5j5r555556617h77777y889	:&:6:J:S::;;;;;;L0>h>t>y>>>{??P070000J233344444A8g9x9==>`0r2y2335555555555555555666666$6*60666<6B6H6N6T6Z6`6f6l6r6x6~666666666666666666666677777 7&7,72787>7D7J7P7V7\7b7h7n7t7z77777777
8+8?8E899<>?%?3?p(011$1(1,101111111<4:H<<<<==
======"=&=*=.=2=6=:=>=B=F=J=N=R=V=Z=^=b=f=j=n=2l444444444444444444444444444455
55T5g555A7x7777777+8084888<8 222222223333@3D3H3L3P3T3444444444444444455555555 5$5(5,5054585<5@5D5H5L5P5T5X5\5`5d5h5l5p5t5x5|55555555555555555555555555555555566666666 6$6(6,6064686<6@6D6H6L6800000 0$0(0,0004080<0@0D0H0L0P0T0X0\0`0d0h0222P2X2\2`2d2h2l2p2t2x2|22222223333333333333444444$4(4,4044444444444444444555555000000 0$0(0,0004080<0@0D0H0L0P0T0X0\0`0d0h0l0p0t0x0|000000000000000000000000000000011111111 1$1(1,1014181<1@1D1H1L1P1T1X1\1`1d1h1:::::: :$:(:,:0:4:8:<:@:D:H:L:P:T:X:\:`:d:h:l:p:t:x:|:::::::::::::::===> 77777777888$808<8H8T8`8l8x88888888888899 9,989D9P9\9h9t999999999999:::(:4:@:L:X:d:p:|:::::::::::;;;(;4;@;L;X;d;p;|;;;;;;;;<<<<$<,<4<<>>>$>,>4><>D>L>T>\>d>l>t>|>>>>>>>>>>>>>>>>>????$?,?4?>>> >(>0>8>@>H>P>X>`>h>p>x>>>>>>>>>>>>>>>>>???? ?(?0?8?@?H?P?X?`?h?p?x?????????????????@0000 0(00080@0H0P0X0`0h0p0x000000000000000001111 1(10181@1H1P1X1`1h1p1x111111111111111112222 2(20282@2H2P2X2`2h2p2x222222222222222223333 3(30383@3H3P3X3`3h3p3x333333333333333334444 4(4>>>>PH88888889999$9,949<9D9L9T9\9d9l9t9|9999999@:D:` <<<<=======x99: :$:4:8:@:X:h:l:|::::::::::::;;;;;$;<;L;P;`;d;h;p;;;;;;;;;;;;;<tpj\V\q@YYt_Wp@؃u'jWp@utWhhr@jՃWjYYuhp@t
Whhr@jՃ\Fu[_]3@^USVW=p@39uuEVhuVVSu׃Ep@uu uuuPt	Pp@/9u ujU YYt.VhjVVSu׃Eu%9u uhr@ujU YY9u t
ujU YYEPuup@}EPPPWp@9uu	Wp@\VuVjVWp@W=p@׃u9u t8uhr@&VVVjSp@SE׋E;u9u tuhr@jU 3_^[U8}S]VWj8EjPpZEEȋE@E̋Ej8hs@E؍Ej3P]F2}tt*Phr@EjP4;YYtt
Phr@j׃3EPJYt,t
Phr@j׃339uuuuSYFSp@_^[U(ES]L+AQ+ƒ9PKWM}:t3efy
V3@^_[ËE}4N*>PKE?PK9V.uMN VGF*OMUDE܍PYHEPYM<\ths@PXYYPp@eEE8t;EE0XPuE0Pq@EEMȃ8EuGPuPhq@t/u\@uPJXYM<\tNu3fFP3fFPvuPjt"uOvvQuP^}tE@PE@
PujUE@
E9E=0M3WsEPWE_M+؍PMWM<\t)PhWYM</ths@PGWYYE\t/u@KSPPhq@]3UEPh@u@u]ujmhD@@]UEPh@u@u]uj5hD@@]U=4@VWu hh@p@t3hP@Pp@4@EPh@u@tY=4@uh8@5,@@YY;3|@u6h\@WUhH@h5@SRYD$tjPYYt$`p@=4@tB=@t9h,@WUhH@h5@SYtjVAYYV`p@3_^][8@tPq@Yt$@q@%4@Y8@USV5p@W}hظ@Whĸ@Wh@WEh@WEh@WEh@WE395<@u3J;tC9ut>9ut99ut49ut/;t+39uh`@UuuU_^[ÁP<@SUV3Wt$3;t@A=$r@PVhS5@VVUS5@׉t$5<@$hcD$6D$D$ h@P,r@D$(P$ttD$t$D$ 6h@P,r@D$,Pjjt$US5@6h5@0r@vuD$_^][PUhV5,r@Wh @hP@PE֍Pq@=p@uׅ5@E5$@h @PփE5p@PPEPhօtEPPEPhօt3,hȵ@P4DuP%DP_^USV3WSSDq@
q@5q@@Թ@QWPE֡q@ PWuh @$;u0p@Pth@P,r@tPuVYEYV`p@q@=q@@Pסq@5q@@P֡q@ Pסq@ Pփ9]ht@4C$p@uq@jSq@PEuq@jjuEӋED8Pq@؃(t:ht@SBu;ujPq@uÀ$8SSq@$h`@Yuq@EY_^[UQQSV5p@W}hظ@Whĸ@Wh@WEh@WEhع@WE֋3;t;9Et69Et19Et,;t(h`@UW uUtU_^[USV5p@W}h@Wht@Wh\@WEhL@WEh<@WEh(@WEh@WEh@WE3E;9u9u9u9ut{9utv9utqh@ӋY;t?h@WUh@W@U,@Ȱ@jVUP6WU(@rE@E@E@EP@3jX_^[UV5r@W3jWWEWPօtEPr@EPr@jWWEWP_^U@El@=tEX@VW3MWQWjWW\@WVPp@;t5ujWh@Lr@PPr@3Wh@VLr@PPr@@@=q@SVuhԻ@P׍hԹ@Pq@$@EPq@q@EPӍEPPh@hPq@q@P5$@h`@h@5$@ӃHuh@5$@5@5$@Vhx@P׃ EPEP3PhPPPPup@tjh`@PLr@PPr@up@}uPh\@hH@5$@Ӄh@5@5$@h8@P׍P>@PPjjh,@up@tjh@PLr@PPr@Ph,@Ph\@h@5$@Vuh@P׍h@Pq@Pj5@E5d@q@@uq@VuVuh@P׍P> @@PPjjVup@tjh@PLr@PPr@PVPh\@h@5$@ӃjX[_^U=}NV}K}W39=4@)@ƅ=@
S0r@hp@hu}Ed@}Ӎh @P=hX@P<VP<$@;tQh @h@@Pq@WWDq@
q@5q@@Թ@QWPEփuPPh0@Lr@PPr@q@ PWuփuPPh @Lr@PPr@hjq@Pr@Eh @EHYt{V4th@RYY;N;t
+V+щ0@+FMh+F+~q@YPhp@tmSjh@Pp@tT3PPPvPSjEtLvWPq@u(|W@q@MuEp@jXh@p@PYY3_^[̋T$3;tMB;tFHJJJB0HHH H(H,H0H8H<0@HlHPHL3ø̋D$W3;81|$8Vt$;9~ ~u
F ]@~(9~$uF$]@F(h0%jPV ;u^_ËL$;ωF}xB0P}|VH$x4^_PF(PV$~^_ø_SUl$]VWC43;u(K$M(jPQU ;ljC4u
_^][9{(uK${0{,S(}K(+;r*u{4+ȃK(_^]C0K,3[+K0;ȉL$vȉL$S0{4u+ʃL$+t(u{4ȋ+ʃ_C0C(^C,]3[Ë{0C(;Љ{0uC0S,;sщS,_^]3[̋D$8SX|Hq8uHa;uHPUk3UUUR$CjD$4D$4D$5KPQ5$Cl$C Ct@0CL$%3ҹL$рtD$L@\}@C$L$;vL$LD$AH}@h3UUUSLT$L$X҃CA0	l$1D$L@0}@D$s'nO|$FD$t$r<CtL$LA\}@tT$LB}@K tCt%D$D$$D$%KjD$(PQ"C33 sOF D$rK tACt7D$D$$ȋD$'jD$(L$)T$*KPQ8"C33s(TO|$FD$t$rًK tЁQK ACt%D$D$$jT$(D$)CRP!C3D$3Ktvs-O|$FD$t$rًK ɉC@tACt%D$D$$D$%KjD$(PQ5!C3D$3K tAKK@;ωL$vωL$S tHR҉T$8t=S zs@R+49;v+׋ʋT$8t$ʃL$|$t$StD$KPVQ L$(CD$S@++щ|$t$S@K@C@Kt3ɍ1AL$K ɉT$,t-Q҉T$8t"S@;Q sL$8|$D$8D$,C@D$8L$,tL$;rKtT$CRVPCD$L$+L$,ɉ|$t$K tAC@K31AL$K ɉT$,t-Q$҉T$8t"S@;Q(sL$8|$D$8D$,C@D$8L$,tL$;rKtT$CRVPCD$L$+L$,ɉ|$t$K tA$KtOs'
O|$FD$t$rًK;tT$LB}@R
3l$C tK	H,S B0jjjLL$XCA0D$
 s'_
O|$F D$t$rًȋЁ3Ҋt$L$LCA03D$3
KjjjT$XCB0D$|$PKt̓+D$Ts$O|$Ft$r݋ȃKȃMws$H]@
D$CLs@CT	CP{@CXD$D$T$LB|@D$̓+ D$s+d$O|$F D$t$rًЋҁ;tL$LA|@.3K@D$3K@ɉL$;vωL$T$ ;vʉL$Rt$|$(ʋT$L$t$|$ +t$t$(щT$S@++щ|$ |$t$(t$S@
s#
O|$Ft$r݋ȃЉK`ȃK\K`BSdD$ʃChKh;K\s[s#_
O|$Ft$r݋ShU{@3ɊD$fLSpKhAKh;K\rKh;s*3$d$ShU{@fLSpShB;ЉShr千0KlCLRCTPQjCpPjXD$4D$t L$LA|@1	T$LB|@!	ChK`Sd9ShKTKLJ#Ћ;ՉL$@v<A	KTOºKLF|$J#Ћ;Չt$L$@wċT$@fsR;L$s&L$OF;|$t$rfT$B+KhfTKpKhAD$KhHuh͍Q;L$s+L$OFQ;|$t$r+KhɉD$bLKnL$,ȃfՉT$uJJ;s-d$$O|$‹T$FJ;t$r׋ȃDJ;s)O|$‹T$FJ;t$r׋ȃ+D$,{dSh{`;׉D$tT$,{hfT{p{hGI{hu|$S`Kd9Kh;0KlCLRS`CTPQ	RCpPj
D$4t8L$LD$Ap|@T$LBT|@L$L|$AT|@vSlKlSPRCXPQK`CdPTKpRjP
D$4tD$L@<|@D$)D$rg|$ r]D$LT$ L$(PT$0HL$R0xPK8k<|D$THP0xC8k<L$(T$ t$|$D$KTKLJ#Ћ;͉T$@v<KTOºKLF|$J#Ћ;͉t$T$@wĄΉL$3ɊʉT$,L$L$J#L$@ыKLL$,T$@;ՉL$v[IT3ɊL$,O‹T$F|$ʺL$t$J#L$.ыKLՉL$@L$;wT$@++L$@҉D$K@uw tg@tT$LB |@LSHKHtE;s%KHOF;|$t$rۋKHK@J#ʉK@KH+KXKPJ#Ћ;͉T$@v<,KXOºKPF|$J#Ћ;͉t$T$@wΉL$3ɊʉT$,L$L$J#L$@ыKPL$,T$@;ՉL$v^3ɊL$,O‹T$F|$ʺL$t$J#L$.ыKPՉL$@L$;wT$@++@D$tL$LA|@L$@KDSHKHtI;s%KHOF;|$t$rۋKHKDJ#ʉKDKH+D$T$ K,+L$09KDvT$LB{@-L$ T$0+ыKD;v<+ʋS0;ʉL$v+ʋS4S(L$+S4+S0L$T$,S@;ʉT$8vT$(+ыK@T$,L$8L$T$ ;vʉL$+щT$ T$8+щS@L$,L$(T$,AL$(L$BIT$,L$uۋK@ncL$(S@AL$(L$ >K s'O|$F D$t$rًL$0+L$ T$LJSхɉL$0St8CSL$(D$0Pt+QR	+QRL$XCA0D$KT$ ɉT$0u'3Ҋt$L$8ʋʉL$8;Kt
L$LA{@`3D$3KK s'O|$F D$t$r;CtSL$LA{@d_^][8ËL$LT$(QT$ y_1Q^k@3L$@ȋD$@L$H#L$$̉D$+٨t‹L$;؉L$s(jBT$;sjBT$+M#͋l$L$D+;l$+;l$HnL$,D$Iu*D$(+ȋD$T;+ʼnD$Td$AAFMus;sS+D$(+l$D$T;sc+ʼnD$TAAFMuL$,D$l$TI;s<+l$TD$@AAFMu+ȋD$T;s+ʼnD$TAAFMuD$+ȋD$Tv7PEAAFQAFT$TAAFMT$Tu݋T$D$Tt^AAF|$TvPIFH+ō$H@FH@FH@FL$TL$TwۅtH@F|$Tv@Fl$;T$0sQ;t$4EL$PD$A{@,L$PA|@ t	ED$P@ |@E++ً˸L$PH#BFAD$0+ƒAD$4+A}8_^]<][<̃|$3҉D$+Dž~|$AB;rt$HT$(ЉD$<$T$(u
=֋$D$DL$ +T$8fLG$*ÅD$@D$fD$t]t$ d$t L$@D$8#;tD$73ۉD$D$ЋˋL$JtutH#ȋuT$(T$ȉ$_^]3[|_^][|̋L$S\$Wu1D$ʁrr_[Vt$u	^_[Ãs3tFKur3Ҿ^_[Án^U[IVVVVVVVVV	V
VVV
VVHw3ҹǿ3MF]VVVVVVVVV	V
VVV
VVʃHttFKu3ҹǾ3^_[QSVt&It3Ҋ3ЁP@3ANu߃ UW3܋,P@ҋP@3Ջ؉D$,P@Y3%3P@3Ӌދ,P@P@3ŋډT$,P@Y3Ł3P@3Ã܋,P@ҋP@3Ջ؉D$,P@Y3%3P@3Ӄދ,P@P@3ʼnT$,P@Y3ŋ,P@33ËЃҋP@D$3P@,P@3%3P@3Ӌދ,P@P@3ŋ,P@Y3ʼnT$3P@3Ã܋,P@ҋP@3ՉD$,P@Y%3Ջ,P@33Ӌދ,P@P@3,P@T$P@3Ń3Ã OrH3܋,P@D$|$"u:Fu:t<"u>"uFu:t< v]ЍEPp@EtE> vFuj
XPVSSdp@PAEPp@E	MPQYYËeup@%p@%q@hh
YY3%0q@%8q@B2 اȧlTD|`4,8JXl|Τ0FZh|H$^4֣ȣn
TL>6ک^nzΪB$0:Ωĩ~ĨΨب",6>FNV`jt|bئ̦vh`T>2&Хĥ΢CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

incorrect length checkincorrect data checkinvalid distance too far backinvalid distance codeinvalid literal/length codeinvalid distances setinvalid bit length repeatinvalid literal/lengths settoo many length or distance symbolsinvalid code lengths setinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method~@~@~@}@}@}@}@}@}@~@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionary inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScs	
!1Aa 0@`@@0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfaFFFn@1n@ޢXrh(pXp,(qt4p@Tp$rq(*pB2 اȧlTD|`4,8JXl|Τ0FZh|H$^4֣ȣn
TL>6ک^nzΪB$0:Ωĩ~ĨΨب",6>FNV`jt|bئ̦vh`T>2&Хĥ΢SCoUninitialize
CoCreateInstance-CoInitializeole32.dllIPropertySheetACreatePropertySheetPageACOMCTL32.dllqSetLastError-CreateDirectoryA
GetFileAttributesAMapViewOfFile5CreateFileMappingACloseHandlelSetFileTime_DosDateTimeToFileTimeGetLastError4CreateFileAUnmapViewOfFilelstrlenA>GetProcAddressLoadLibraryAMultiByteToWideCharLocalFreeFormatMessageAFreeLibrary&GetModuleHandleAuGetVersionExAWDeleteFileA4GetPrivateProfileIntA:GetPrivateProfileStringA,ResumeThreadwSetPriorityClassGetCurrentProcessGetCurrentThreadSetThreadPriorityDCreateProcessA$GetModuleFileNameA'RemoveDirectoryAGetFileSizecGetTempFileNameAeGetTempPathAKERNEL32.dllMessageBoxAGetFocusSendMessageAEndPaintFGetSystemMetricsBeginPaintDefWindowProcAPostMessageA,SetDlgItemTextAwsprintfA5GetParentSendDlgItemMessageAReleaseDCGetDCMoveWindow\GetWindowRectGetDlgItemDispatchMessageATranslateMessagePeekMessageA&SetCursorLoadCursorAUpdateWindowjShowWindowYCreateWindowExARegisterClassAUSER32.dllSDeleteObjectSetTextColorTextOutASetBkModeSelectObject6CreateFontA0CreateDIBitmapMCreateSolidBrushGDI32.dll[RegCloseKeyrRegOpenKeyExA{RegQueryValueExAgRegEnumKeyExAzRegQueryValueARegSetValueExA_RegCreateKeyExAbRegDeleteKeyAdRegDeleteValueAADVAPI32.dllrShellExecuteASHELL32.dllstrchrmemcpymemsetstrncatstrcatstrlenstrcpystrcmpstrrchrXfprintf_vsnprintfmalloc_snprintfstrncpy^freesscanf_putenvremove]freaddftellbfseekWfopenLfcloseOfflush_freopen_iobffwritestrftimelocaltimetimesprintf_fstatstrtol_pctype_isctypea__mb_cur_maxqsortreallocRfgetsstrncmpc__p___argvb__p___argcMSVCRT.dll_exitH_XcptFilterIexit_acmdlnX__getmainargs_initterm__setusermatherr_adjust_fdivj__p__commodeo__p__fmode__set_app_type_except_handler3_controlfpPGetStartupInfoA_strnicmp_strcmpi_strdup_tempnam_close_read_open@D@@D@@D@@@ز@D@@IJ@@IJ@@D@@@ز@D@@@@l@T@<@,@@@@@@б@@@@@~@@@@@Software\Microsoft\Windows\CurrentVersion\UninstallSoftware\Microsoft\Windows\CurrentVersion\Uninstallmessage_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBsno such folder (%s)unknown CSIDL (%s)function not availableSHGetSpecialFolderPathAshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissi100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Runtime ErrorTimes RomanThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Don't know Python's installation typeStrange\python%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Py_OptimizeFlagPySys_GetObjectPyRun_SimpleStringPy_FinalizePy_SetProgramNamePy_Initialize%s%cimport py_compile; py_compile.compile (r'%s')SOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOut of memory!rbRunning the pre-installation script failed
Can't load Python for pre-install script (%d)aPyErr_PrintOSErrorValueError__builtin__PyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleUninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINEPostinstall script finished.
Click the Finish button to exit the Setup wizard.*** Could not load Python ****** run_installscript: internal error 0x%X ***
freopen stdoutfreopen stderr300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...Installation failed.Running Script...Could not open postinstall-script %s
PySys_SetArgv*** Installation finished %Y/%m/%d %H:%M ***
IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasBad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup %sCould not register window classSetup.exeSetupWindowClassif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of argsSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archiveCould not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py) 8nhklmn				 0
8Z@(n,	BBB999111)))cR[RABZRYRZRAB[R[RAB[RAAB[ && &&&@JQ1AA1ZQ1111ZQ1AAZ@JQ1AAZQ1AAJ eu eu @ABZ@J@G@F@F@G@AABX@J@AABX@J@J@AA1X@J@G@HRX@G@AAG@ZRX@AAG@JQJed%ed%ed@AA1ZQ1AA1X@J@HQ1AA1X@1A1ZQ1AA1ZQ1A1J  & & RAABZRABZR[R[RABZRYRBZRABZRBW@J@J &R[R[R[R[R[RABZR[R[R[ & & & & & & &@J@J@J@J@HQ1AA1X@J@J@J@J@J@J@G@J@G@JQJ@ABZQ11Z@J@AAG@J@G@GQ1J@AA1ZQ1YQ1[@J@AAG@J@G@1W@J&@I@G@J@J@J@J@G@J@G@Z@J@AA1X@J@HRABX@J@HQ1AA1X@J@J  &  %& & & &RAABZR[RZRAAABZR[R[RABZR[R[@H{SetupMS Sans SerifP}
This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.P}PhnP}@H{SetupMS Sans SerifP}
Select python installation to use:PP}7Python Directory:P}jPhnPP}BInstallation Directory:@B2Find other ...@H{SetupMS Sans SerifP}
Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.P}msctls_progress32Progress1P}Installation progress:Phn@H{SetupMS Sans SerifP}
Click the Finish button to exit the Setup wizard.PhnP}(././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/wininst-7.1.exe0000644000175100001730000020000014467657412024165 0ustar00runnerdockerMZ@(	!L!This program cannot be run in DOS mode.

$IoA'tpj\Vd@YYt_W@؃u'jW@utWh@jՃWjYYuh@t
Wh@jՃ\Fu[_]3@^USVW=@39uuEVhuVVSu׃E@uu uuuPt	P@/9u ujU YYt.VhjVVSu׃Eu%9u uhĂ@ujU YY9u t
ujU YYEPuu@}EPPPW@9uu	W@\VuVjVW@W=@׃u9u t8uh@&VVVjS@SE׋E;u9u tuh@jU 3_^[U8}S]VWj8EjPpZEEȋE@E̋Ej8h@E؍Ej3P]F2}tt*Ph@EjP4;YYtt
Ph@j׃3EPJYt,t
PhԂ@j׃339uuuuSYFS@_^[U(ES]L+AQ+ƒ9PKWM}:t3efy
V3@^_[ËE}4N*>PKE?PK9V.uMN VGF*OMUDE܍PYHEPYM<\th @PXYYP؀@eEE8t;EE0XPuE04@EEMȃ8EuGPuPp@t/u\@uPJXYM<\tNu3fFP3fFPvuPjt"uOvvQuP^}tE@PE@
PujUE@
E9E=0M3WsEPWE_M+؍PMWM<\t)PhWYM</th @PGWYYE\t/u@KSPPp@]3UEPh@u,@u]ujmhT@(@]UEPh@u,@u]uj5hT@(@]U=D@VWu hh@Ѐ@t3hP@PԀ@D@EPh@u,@tY=D@uh8@5L@$@YY;3|@u68@YYt)G@ruh$@5@$@3_^Ëx@jPPjD@tPh@(@YYuh@5L@U,V3Vuuuuuup@;}Ph@EPEPEPEPEPEPEPh@u,@$FEPhh@jVhx@t@;}Phl@EURh@P;}PhD@EuPQP;}Ph$@pEu܋PQ;}Ph@X9utEuPQ,;}Ph@;9utuEuPQD;}Ph@9ut'EuPQ$;}Ph@5L@$@GhPjuVV̀@EjRPQ;}h\@WUhH@h50@SRYD$tjPYYt$@=T@tB=@t9h,@WUhH@h50@SYtjVAYYV@3_^][H@tP@Yt$<@%T@YH@USV5Ԁ@W}h@Wh@Wh@WEh@WEh@WEh@WE395L@u3J;tC9ut>9ut99ut49ut/;t+39uh@UuuU_^[ÁPL@SUV3Wt$3;t@A=H@PVhS50@VVUS50@׉t$5L@$hcD$6D$D$ h@PP@D$(P$ttD$t$D$ 6h@PP@D$,Pjjt$US50@6h50@T@vuD$_^][PUhV5P@Wh@@hP@PE֍P@=Ѐ@uׅ5@E5D@h @PփE5@PPEPhօtEPPEPhօt3,h@P4DuP%DP_^USV3WSS@@
ȁ@5ā@@@QWPE֡ȁ@ PWuh@@$;u0@Pth@PP@tPuVYEYV@ȁ@=@@Pסȁ@5@@P֡ȁ@ Pסȁ@ Pփ9]ht@4C$p@u@jS@PEu@jjuEӋED8P@؃(t:ht@SBu;ujP@uÀ$8SS@$h`@Yu@EY_^[UQQSV5Ԁ@W}h@Wh@Wh@WEh@WEh@WE֋3;t;9Et69Et19Et,;t(h@UW uUtU_^[USV5Ԁ@W}h@Wht@Wh\@WEhL@WEh<@WEh(@WEh@WEh@WE3E;9u9u9u9ut{9utv9utqh@ӋY;t?h@WUh@W@UL@@jVUP6WU(@rE(@E,@E$@Ep@3jX_^[UV5(@W3jWWEWPօtEP,@EP0@jWWEWP_^U@El@=tEX@VW3MWQWjWW\@WVP@;t5ujWh@@P8@3Wh@V@P8@`@=܁@SVuh@P׍h@P@D@EP؁@ԁ@EPӍEPPh@hPЁ@@P5D@h@h@5D@ӃHuh@5D@5@5D@Vhx@P׃ EPEP3PhPPPPu@tjh`@P@P8@u@}uPh\@hH@5D@Ӄh@5@5D@h8@P׍P>@PPjjh,@u@tjh@P@P8@Ph,@Ph\@h@5D@Vuh@P׍h@P@Pj5@E5@́@@u@VuVuh@P׍P> @@PPjjVu@tjh@P@P8@PVPh\@h@5D@ӃjX[_^U=}NV}K}W39=T@)@ƅ=@
ST@hp@hu}Ed@}Ӎh@@P=hX@P<VP<D@;tQh@@h@@P@WW@@
ȁ@5ā@@@QWPEփuPPh0@@P8@ȁ@ PWuփuPPh @@P8@hj @P$@Eh@@EHYt{V4th@RYY;N;t
+V+щP@+FMh+F+~@YPh@tmSjh@P܀@tT3PPPvPSjEtLvWP@u(|W<@MuE@jXh@@PYY3_^[̋T$3;tMB;tFHJJJB0HHH H(H,H0H8H<0@HlHPHL3ø̋D$W3;81|$8Vt$;9~ ~u
F ]@~(9~$uF$]@F(h0%jPV ;u^_ËL$;ωF}xB0P}|VH$x4^_PF(PV$~^_ø_SUl$]VWC43;u(K$M(jPQU ;ljC4u
_^][9{(uK${0{,S(}K(+;r*u{4+ȃK(_^]C0K,3[+K0;ȉL$vȉL$S0{4u+ʃL$+t(u{4ȋ+ʃ_C0C(^C,]3[Ë{0C(;Љ{0uC0S,;sщS,_^]3[̋D$8SX|Hq8uHa;uHPUk3UUUR$CjD$4D$4D$5KPQ5$Cl$C Ct@0CL$%3ҹL$рtD$L@t@C$L$;vL$LD$A`@h3UUUSLT$L$X҃CA0	l$1D$L@H@D$s'nO|$FD$t$r<CtL$LAt@tT$LB,@K tCt%D$D$$D$%KjD$(PQ"C33 sOF D$rK tACt7D$D$$ȋD$'jD$(L$)T$*KPQ8"C33s(TO|$FD$t$rًK tЁQK ACt%D$D$$jT$(D$)CRP!C3D$3Ktvs-O|$FD$t$rًK ɉC@tACt%D$D$$D$%KjD$(PQ5!C3D$3K tAKK@;ωL$vωL$S tHR҉T$8t=S zs@R+49;v+׋ʋT$8t$ʃL$|$t$StD$KPVQ L$(CD$S@++щ|$t$S@K@C@Kt3ɍ1AL$K ɉT$,t-Q҉T$8t"S@;Q sL$8|$D$8D$,C@D$8L$,tL$;rKtT$CRVPCD$L$+L$,ɉ|$t$K tAC@K31AL$K ɉT$,t-Q$҉T$8t"S@;Q(sL$8|$D$8D$,C@D$8L$,tL$;rKtT$CRVPCD$L$+L$,ɉ|$t$K tA$KtOs'
O|$FD$t$rًK;tT$LB@R
3l$C tK	H,S B0jjjLL$XCA0D$
 s'_
O|$F D$t$rًȋЁ3Ҋt$L$LCA03D$3
KjjjT$XCB0D$|$PKt̓+D$Ts$O|$Ft$r݋ȃKȃMws$H]@
D$CL(@CT	CP(@CXD$D$T$LB@D$̓+ D$s+d$O|$F D$t$rًЋҁ;tL$LA@.3K@D$3K@ɉL$;vωL$T$ ;vʉL$Rt$|$(ʋT$L$t$|$ +t$t$(щT$S@++щ|$ |$t$(t$S@
s#
O|$Ft$r݋ȃЉK`ȃK\K`BSdD$ʃChKh;K\s[s#_
O|$Ft$r݋ShU@3ɊD$fLSpKhAKh;K\rKh;s*3$d$ShU@fLSpShB;ЉShr千0KlCLRCTPQjCpPjXD$4D$t L$LAȌ@1	T$LB@!	ChK`Sd9ShKTKLJ#Ћ;ՉL$@v<A	KTOºKLF|$J#Ћ;Չt$L$@wċT$@fsR;L$s&L$OF;|$t$rfT$B+KhfTKpKhAD$KhHuh͍Q;L$s+L$OFQ;|$t$r+KhɉD$bLKnL$,ȃfՉT$uJJ;s-d$$O|$‹T$FJ;t$r׋ȃDJ;s)O|$‹T$FJ;t$r׋ȃ+D$,{dSh{`;׉D$tT$,{hfT{p{hGI{hu|$S`Kd9Kh;0KlCLRS`CTPQ	RCpPj
D$4t8L$LD$A@T$LBl@L$L|$Al@vSlKlSPRCXPQK`CdPTKpRjP
D$4tD$L@T@D$)D$rg|$ r]D$LT$ L$(PT$0HL$R0xPK8k<|D$THP0xC8k<L$(T$ t$|$D$KTKLJ#Ћ;͉T$@v<KTOºKLF|$J#Ћ;͉t$T$@wĄΉL$3ɊʉT$,L$L$J#L$@ыKLL$,T$@;ՉL$v[IT3ɊL$,O‹T$F|$ʺL$t$J#L$.ыKLՉL$@L$;wT$@++L$@҉D$K@uw tg@tT$LB8@LSHKHtE;s%KHOF;|$t$rۋKHK@J#ʉK@KH+KXKPJ#Ћ;͉T$@v<,KXOºKPF|$J#Ћ;͉t$T$@wΉL$3ɊʉT$,L$L$J#L$@ыKPL$,T$@;ՉL$v^3ɊL$,O‹T$F|$ʺL$t$J#L$.ыKPՉL$@L$;wT$@++@D$tL$LA @L$@KDSHKHtI;s%KHOF;|$t$rۋKHKDJ#ʉKDKH+D$T$ K,+L$09KDvT$LB@-L$ T$0+ыKD;v<+ʋS0;ʉL$v+ʋS4S(L$+S4+S0L$T$,S@;ʉT$8vT$(+ыK@T$,L$8L$T$ ;vʉL$+щT$ T$8+щS@L$,L$(T$,AL$(L$BIT$,L$uۋK@ncL$(S@AL$(L$ >K s'O|$F D$t$rًL$0+L$ T$LJSхɉL$0St8CSL$(D$0Pt+QR	+QRL$XCA0D$KT$ ɉT$0u'3Ҋt$L$8ʋʉL$8;Kt
L$LA@`3D$3KK s'O|$F D$t$r;CtSL$LAЋ@d_^][8ËL$LT$(QT$ y_1Q^k@3L$@ȋD$@L$H#L$$̉D$+٨t‹L$;؉L$s(jBT$;sjBT$+M#͋l$L$D+;l$+;l$HnL$,D$Iu*D$(+ȋD$T;+ʼnD$Td$AAFMus;sS+D$(+l$D$T;sc+ʼnD$TAAFMuL$,D$l$TI;s<+l$TD$@AAFMu+ȋD$T;s+ʼnD$TAAFMuD$+ȋD$Tv7PEAAFQAFT$TAAFMT$Tu݋T$D$Tt^AAF|$TvPIFH+ō$H@FH@FH@FL$TL$TwۅtH@F|$Tv@Fl$;T$0sQ;t$4EL$PD$A@,L$PA @ t	ED$P@8@E++ً˸L$PH#BFAD$0+ƒAD$4+A}8_^]<][<̃|$3҉D$+Dž~|$AB;rt$HT$(ЉD$<$T$(u
=֋$D$DL$ +T$8fLG$*ÅD$@D$fD$t]t$ d$t L$@D$8#;tD$73ۉD$D$ЋˋL$JtutH#ȋuT$(T$ȉ$_^]3[|_^][|̋L$S\$Wu1D$ʁrr_[Vt$u	^_[Ãs3tFKur3Ҿ^_[Án^U[IVVVVVVVVV	V
VVV
VVHw3ҹǿ3MF]VVVVVVVVV	V
VVV
VVʃHttFKu3ҹǾ3^_[QSVt&It3Ҋ3Ёh@3ANu߃ UW3܋,h@ҋh@3Ջ؉D$,h@Y3%3h@3Ӌދ,h@h@3ŋډT$,h@Y3Ł3h@3Ã܋,h@ҋh@3Ջ؉D$,h@Y3%3h@3Ӄދ,h@h@3ʼnT$,h@Y3ŋ,h@33ËЃҋh@D$3h@,h@3%3h@3Ӌދ,h@h@3ŋ,h@Y3ʼnT$3h@3Ã܋,h@ҋh@3ՉD$,h@Y%3Ջ,h@33Ӌދ,h@h@3,h@T$h@3Ń3Ã OrH3܋,h@D$|$PfzxTh~سDjXL6&ֺκĺ
.>L^r»̻ػ|nd\R޸$.8BPZfpxʹԹܹ$.:JԵȵ6$ܶȶt^RF4$ĸCreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

incorrect length checkincorrect data checkinvalid distance too far backinvalid distance codeinvalid literal/length codeinvalid distances setinvalid bit length repeatinvalid literal/lengths settoo many length or distance symbolsinvalid code lengths setinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method(@@@@@@@Ѝ@@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionary inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScs	
!1Aa 0@`@@0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfaFFFn@n@]o@ao@o@o@6(XHз4tԸpp@bRڷ.Ttd´޴*>PfzxTh~سDjXL6&ֺκĺ
.>L^r»̻ػ|nd\R޸$.8BPZfpxʹԹܹ$.:JԵȵ6$ܶȶt^RF4$ĸdPropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrorECreateDirectoryAVGetFileAttributesA^MapViewOfFileNCreateFileMappingA.CloseHandleSetFileTimeDosDateTimeToFileTimeiGetLastErrorMCreateFileAcUnmapViewOfFilelstrlenAGetProcAddressHLoadLibraryAkMultiByteToWideCharRLocalFreeFormatMessageAFreeLibrarywGetModuleHandleAGetVersionExA|DeleteFileAGetPrivateProfileIntAGetPrivateProfileStringAResumeThread$SetPriorityClass:GetCurrentProcess=GetCurrentThread6SetThreadPriority`CreateProcessAuGetModuleFileNameARemoveDirectoryA[GetFileSizeGetTempFileNameAGetTempPathAKERNEL32.dllMessageBoxAGetFocus;SendMessageAEndPaint]GetSystemMetrics
BeginPaintDefWindowProcAPostMessageASSetDlgItemTextAwsprintfAEGetParent6SendDlgItemMessageA*ReleaseDCGetDCMoveWindowtGetWindowRectGetDlgItemDispatchMessageATranslateMessagePeekMessageAMSetCursorLoadCursorAUpdateWindowShowWindow`CreateWindowExARegisterClassAUSER32.dllDeleteObject<SetTextColorNTextOutASetBkModeSelectObject9CreateFontA3CreateDIBitmapPCreateSolidBrushGDI32.dllRegCloseKeyRegOpenKeyExARegQueryValueExARegEnumKeyExARegQueryValueARegSetValueExARegCreateKeyExARegDeleteKeyARegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dllhCoUninitializeCoCreateInstance:CoInitializeole32.dllstrchrmemcpymemset
strncatstrcatstrlenstrcpystrcmpstrrchrfprintf%_vsnprintfmalloc_snprintfstrncpyfreesscanf_putenvremovefreadftellfseekfopenfclosefflushfreopenC_iobfwritestrftimelocaltimetimesprintf_fstatstrtol_pctypeE_isctypey__mb_cur_maxqsortreallocfgetsstrncmp{__p___argvz__p___argcMSVCR71.dll_c_exit_exitK_XcptFilterM_ismbblead_cexitexit_acmdln_amsg_exitn__getmainargs?_initterm__setusermatherr_adjust_fdiv__p__commode__p__fmode__set_app_type_except_handler3k__dllonexit_onexit_controlfpGetStartupInfoA_strnicmp_strcmpi_strdup_tempnam_close_read_open@T@@T@@T@@@@T@@@@@@T@@@@T@@@@l@T@<@,@@@@@@@@@@@~@@@@@Software\Microsoft\Windows\CurrentVersion\UninstallSoftware\Microsoft\Windows\CurrentVersion\Uninstallmessage_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBsno such folder (%s)unknown CSIDL (%s)function not availableSHGetSpecialFolderPathAshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissi100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Runtime ErrorTimes RomanThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Don't know Python's installation typeStrange\python%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Py_OptimizeFlagPySys_GetObjectPyRun_SimpleStringPy_FinalizePy_SetProgramNamePy_Initialize%s%cimport py_compile; py_compile.compile (r'%s')SOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOut of memory!rbRunning the pre-installation script failed
Can't load Python for pre-install script (%d)aPyErr_PrintOSErrorValueError__builtin__PyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleUninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINEPostinstall script finished.
Click the Finish button to exit the Setup wizard.*** Could not load Python ****** run_installscript: internal error 0x%X ***
freopen stdoutfreopen stderr300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...Installation failed.Running Script...Could not open postinstall-script %s
PySys_SetArgv*** Installation finished %Y/%m/%d %H:%M ***
IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasBad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup %sCould not register window classSetup.exeSetupWindowClassif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of argsSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archiveCould not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py) 8nhklmn				 0
8Z@(n,	BBB999111)))cR[RABZRYRZRAB[R[RAB[RAAB[ && &&&@JQ1AA1ZQ1111ZQ1AAZ@JQ1AAZQ1AAJ eu eu @ABZ@J@G@F@F@G@AABX@J@AABX@J@J@AA1X@J@G@HRX@G@AAG@ZRX@AAG@JQJed%ed%ed@AA1ZQ1AA1X@J@HQ1AA1X@1A1ZQ1AA1ZQ1A1J  & & RAABZRABZR[R[RABZRYRBZRABZRBW@J@J &R[R[R[R[R[RABZR[R[R[ & & & & & & &@J@J@J@J@HQ1AA1X@J@J@J@J@J@J@G@J@G@JQJ@ABZQ11Z@J@AAG@J@G@GQ1J@AA1ZQ1YQ1[@J@AAG@J@G@1W@J&@I@G@J@J@J@J@G@J@G@Z@J@AA1X@J@HRABX@J@HQ1AA1X@J@J  &  %& & & &RAABZR[RZRAAABZR[R[RABZR[R[@H{SetupMS Sans SerifP}
This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.P}PhnP}@H{SetupMS Sans SerifP}
Select python installation to use:PP}7Python Directory:P}jPhnPP}BInstallation Directory:@B2Find other ...@H{SetupMS Sans SerifP}
Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.P}msctls_progress32Progress1P}Installation progress:Phn@H{SetupMS Sans SerifP}
Click the Finish button to exit the Setup wizard.PhnP}(././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/wininst-8.0.exe0000644000175100001730000017000014467657412024173 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$tpj\VXq@YYt_Wp@؃u'jWp@utWhr@jՃWjYYuhp@t
Whr@jՃ\Fu[_]3@^USVW=p@39uuEVhuVVSu׃Ep@uu uuuPt	Pp@/9u ujU YYt.VhjVVSu׃Eu%9u uhs@ujU YY9u t
ujU YYEPuup@}EPPPWp@9uu	Wp@\VuVjVWp@W=p@׃u9u t8uhr@&VVVjSq@SE׋E;u9u tuhr@jU 3_^[U8}S]VWj8EjPdSEEȋE@E̋Ej8hhs@E؍Ej3P]F2}tt*PhPs@EjP4;YYtt
PhPK?PKV.uMN VGF*OȋEˍDEEPUQEHEEPQM<\tEhps@PQYYEPq@eDEE8t;EE0sQPuE04q@EEMȃ8EuGPuEPdq@EEPQYM<\tGuFPFPvEuPjt"uOvvQuPF}tE@PE@
PujUE@
E9EkKM3PsEEPvP_EM+؍EPMbPM<\t#EPMPYM</tEhps@P/PYYM<\tjPq@S8VVq@$hPx@Yt$q@D$Y_^][U|@3ʼnE39EVt>PPQVuPhp@VPq@p@Pq@+WVPq@jhx@P5@@{V4tRDy@Y;N;t
+V+щ0@+FM+F+~hq@YEEPh\p@tnuEjh@y@PXp@tV3PPPvPujEtKvWPq@uB|WHq@MuEq@3@p@P y@Y3_3^RBŔUV5r@W3EPr@EPr@jWWWEPօu_^UP|@3ʼnE}EEtuuuPxr@SVWMQP|r@j]r@j
Yhxy@3QQQQQQQjhQQQPHp@=Dp@PSjSE4p@ @VsAYPVjjSPp@hu8p@VOAYPVj
j
uuuPUl$|@3ʼnElExSVW=p@xQh3ShE|hz@Pd\tׅt3\SSSSpPEPSxDžpPp@\t;DžpPt8tEPVZ>YY5Dr@EPEhhz@P֍EP|hh~@hWuE~@ur@h@P4h~@P4h@Pu4@;tQh @h~@Pq@SVV4r@5q@E֋=q@@Px@Su׃uPPh~@@r@PEEPEPh`@Wփ;t֍EPEPhL@Wփ;uWgPp@;tGtBE=EPEPh8@Wփ;uWEPEPh$@Wփ;uW	YEE;Eu3vp@tEEp@~P}Y9]Etuuuh@PDr@uuh@PDr@j@h@EPS9ut99ut49ut/;t+39uh@UuuJU^[UQEPh4u@u$@uujht@@UQEPh4u@u$@uujht@@ø'|@3ĉ$$NU$V$-tX-t0H~j$hhUPr@VhUr@VjhhUPr@b3@6@tPjhrhUPr@h@D$hЂ@PDr@5r@D$PhUh@hUv1t(8jjhpUTr@PXr@5Tr@W3WWhpU-@D@PXr@WWhkUPr@@WN%<0\Yt
hps@W%YYW%U0YY(S5`@5H@5r@ء,@t8th@hU5,@Y=D@h@hUh@5@5@WSTuhd@uY=D@=t@ @t9hH@hUh4@h5@+tjpYWp@=D@tB=p@t9h@hUh4@h5@tj%YWp@[_3$^]3^$UtSVWj,3ۍESP&$3]}j0^VESP]
$Su}`p@5(p@EȍEP]E%@Ek։EEP}ElEP)@։EEP}EmEu>@։EEP}EnEf0@SEE4`p@EEEEEEPE ]]]E,p@_^[ø#|@3ĉ$SUVW5@=p@UD$Pt@Sh@؃@VjPYD$ @5@D$UPShЃ@V׋͍D$@@5@jPh@Shă@V5@-p@jh@V5@t@jh@V5@p@j
hP@Sh@V5@jPh@Sh@h@5@hh@Shp@Vh @$P@@YY5@q@@_^][tPp@@tPuBJ^8e~0NlFLRFTPQv`	FpPjEtCE@@NhfUHfTNpFhuFdF`9Fh
닋E@@^NlFPRFXPQvdF`DFpPjEtE@@}r\}rSEMuHMHMMHP^8~<E^8~}'EM;AtE}t
j}E+G]+_G_^~Et,t(GS+Ã~PvtB
FG0Eԃ>u3ɋV҃@VH@H@OI@I@PJ@J@K@L@L@M@&M@3M@M@)MMMAGMu+MM#+MM;Ms)MMAGMu֋MUvLBj3YM@mAGAGAGHuE +ʃmAGAGAG}w}tAG}vIG;]s7;}#,@0@@P@ t
@h@M+)M3AыMJʋU#эKOHM+˃HM+ρHE_V8F<^[Ul$|@3ʼnE\E|UxS]lVutWjE3Y}<339}p]ԉUvKDEU3B3ۃ}h]JEUUMur3@MM*MMM;M}
EfU)~M	UɊUUffM	feE`3ҋ+MBMMMM])U+˃}]u3ҍHBMut	Z#3ۃELEEMM3ҍHButJ#ʋ3ۅuEME؉3M\_^3[`US]VuW3@;u$E;r+;+Mû3]E[QQQQQQQQQ	Q
QQQ
QQHw3Ҿǿ3MIQQQQQQQQQ	Q
QQQ
QQHt+KAu;r+3&KAuƹ3ҋNj3_^[]UQ}SVWйtt3#3@BMu} j_UU3#ы@3@#3@3@3#@3@#3@3@3#ы@3@#3@3@3#@3@#3@3@3#ы@3@#3@3@3#@3@3@#3@3#ы@3@#m 3@3@3#@3@3@#3@Mk9}rDUU3)}#ы@3@3@#3@MuŃ}t3#3@FMu_^[ËT$u3t$D$Y%\q@%`q@%hq@%lq@%pq@;
|@uQL$+ȃY*QL$+ȃY%q@QL$+#ȋ%;r
Y$-h!k@@$@5@@h@h@h@q@@}jYjXh8@3ۉ]]EPp@EEdp@jVWp@t;u3Fhp@3F@;u
j]Y/@u 5@hr@hr@*YYt.5@@;uhr@hr@YY@uSWp@=@th@dYtjjj@r@0u< wLt}uBt
< wFuEtEj
XPVjh@
@=@u[Pr@<"u39MMPr@YtFuF놋E	MPQEYYËeEܣ@=@uPr@=@ur@E@3@ËeE-f=@MZt3Q<@@PEu@tuԃ@v39@t@v39@j@Pq@jTq@YY@@0r@
@,r@
@(r@@=@uhl@$r@Y=@u	j r@Y35U(@
@@@5@=@f@f
@f@f@f%@f-@@E@E@E@(@@@@	@|@@p@ @jlYjp@hȰ@p@= @ujHYh	lp@Pp@%q@jh`@5@5$q@YEuu q@YajYe5@։E5@։EEPEPuEu5Tq@֣@uփ@E	EjYt$XYHVW(@(@;NjstЃ;r_^VW0@0@;NjstЃ;r_^%r@̋L$f9MZt3ËA<8PEu3fx̋D$H<ASVq3҅WDv|$H;r	X;r(;r3_^[jh@ne@RsYt=E+PRYYt+@$ЃE E3=ËeE3T%r@%r@hl@d5D$l$l$+SVW|@1E3PeuEEEEdËMd
Y__^[]Qt$t$t$t$he@h|@Vhh3Vt
VVVVV^3U|@eeSWN@;ǻt
t	У@`VEPp@u3up@3p@3p@3EPp@E3E3;uO@u5|@։5@^_[%Lq@%q@%q@%q@%(q@%,q@%0q@ȹֹ>.
nRB0zbrζ
2@Tl0@TdԵzʾt`B&ڽĽĵRF8"jLVdlv6$ƺкں$2<JT\dlt~ʻԻ޻",BP`jrм 
ظȸzjXJ6*޷ηp^+f@Uh@CreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissilSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueError__builtin__PyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_InitializePyErr_PrintPy_SetProgramNameOut of memory!rbRunning the pre-installation script failed
Can't load Python for pre-install scriptaRuntime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** Could not load Python ****** run_installscript: internal error 0x%X ***
freopen stdoutfreopen stderr300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...if exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removed%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.install_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfoSetuptitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

incorrect length checkincorrect data checkinvalid distance too far backinvalid distance codeinvalid literal/length codeinvalid distances setinvalid literal/lengths setinvalid bit length repeatinvalid code lengths settoo many length or distance symbolsinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression methodincompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionary0@$@t@@@@@؎@@t@ inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScs	
!1Aa 0@`@@0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfaFFF@(@H|@ @l.
nRB0zbrζ
2@Tl0@TdԵzʾt`B&ڽĽĵRF8"jLVdlv6$ƺкں$2<JT\dlt~ʻԻ޻",BP`jrм 
ظȸzjXJ6*޷ηp^dPropertySheetACreatePropertySheetPageACOMCTL32.dll(SetLastErrorKCreateDirectoryA^GetFileAttributesAhMapViewOfFileTCreateFileMappingA4CloseHandleSetFileTimeDosDateTimeToFileTimeqGetLastErrorSCreateFileAqUnmapViewOfFilelstrlenAGetProcAddressRLoadLibraryAuMultiByteToWideCharFreeLibrary\LocalFreeFormatMessageAcGetFileSizeGetTempFileNameAGetTempPathAGetModuleHandleAResumeThread1SetPriorityClassBGetCurrentProcessEGetCurrentThreadDSetThreadPriorityfCreateProcessA}GetModuleFileNameADeleteFileARemoveDirectoryAGetPrivateProfileIntAGetPrivateProfileStringAKERNEL32.dllMessageBoxAGetFocuswsprintfASSetDlgItemTextA;SendMessageA*ReleaseDCGetDCDispatchMessageATranslateMessagePeekMessageAEndPaint]GetSystemMetrics
BeginPaintDefWindowProcAUpdateWindowShowWindow`CreateWindowExARegisterClassALoadCursorAMoveWindowtGetWindowRectPostMessageAEGetParent6SendDlgItemMessageAGetDlgItemMSetCursorUSER32.dll3CreateDIBitmapDeleteObject<SetTextColorNTextOutASetBkModeSelectObject9CreateFontAPCreateSolidBrushGDI32.dllRegQueryValueARegCloseKeyRegQueryValueExARegEnumKeyExARegOpenKeyExARegSetValueExARegCreateKeyExARegDeleteKeyARegDeleteValueAADVAPI32.dlliCoUninitializeCoCreateInstance;CoInitializeole32.dllWstrchr/memcpy3memsetastrncatUstrcat`strlenZstrcpyz_localtime64_time64nstrtolfree$malloc6_putenv_fstat64i32fprintf__iob_funcDremovefreadftellfseekfopenfclosefflushfreopenq_snprintfdstrncpyXstrcmphstrrchr_vsnprintfSsscanffwrite_strftimeOsprintf
isspace>qsortCreallocfgetscstrncmp__argv__argcMSVCR80.dll_amsg_exit__getmainargs/_cexit_exitg_XcptFilter+_ismbbleadexit_acmdln
_initterm_initterm_e?_configthreadlocale__setusermatherr_adjust_fdiv__p__commode__p__fmodem_encode_pointer__set_app_typeN_crt_debugger_hook_unlock__dllonexit|_lock"_onexitc_decode_pointerv_except_handler4_common_invoke_watsonB_controlfp_s)InterlockedExchangeVSleep&InterlockedCompareExchangeGetStartupInfoA^TerminateProcessnUnhandledExceptionFilterJSetUnhandledExceptionFilter9IsDebuggerPresentQueryPerformanceCounterGetTickCountFGetCurrentThreadIdCGetCurrentProcessIdGetSystemTimeAsFileTime_strnicmp_strdup_stricmp<_close=_read#_open_tempnamt@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@t@Software\Microsoft\Windows\CurrentVersion\Uninstallt@t@pt@Pt@8t@ t@t@s@s@s@s@@s@t@s@@s@>@s@<>@ts@@Software\Microsoft\Windows\CurrentVersion\UninstallN@D(@pnklmn	(	8	H	X	hx
 $ZR(n,	BBB999111)))cR[RABZRYRZRAB[R[RAB[RAAB[ && &&&@JQ1AA1ZQ1111ZQ1AAZ@JQ1AAZQ1AAJ eu eu @ABZ@J@G@F@F@G@AABX@J@AABX@J@J@AA1X@J@G@HRX@G@AAG@ZRX@AAG@JQJed%ed%ed@AA1ZQ1AA1X@J@HQ1AA1X@1A1ZQ1AA1ZQ1A1J  & & RAABZRABZR[R[RABZRYRBZRABZRBW@J@J &R[R[R[R[R[RABZR[R[R[ & & & & & & &@J@J@J@J@HQ1AA1X@J@J@J@J@J@J@G@J@G@JQJ@ABZQ11Z@J@AAG@J@G@GQ1J@AA1ZQ1YQ1[@J@AAG@J@G@1W@J&@I@G@J@J@J@J@G@J@G@Z@J@AA1X@J@HRABX@J@HQ1AA1X@J@J  &  %& & & &RAABZR[RZRAAABZR[R[RABZR[R[@H{SetupMS Sans SerifP}
This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.P}PhnP}@H{SetupMS Sans SerifP}
Select python installation to use:PP}7Python Directory:P}jPhnPP}BInstallation Directory:@B2Find other ...@H{SetupMS Sans SerifP}
Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.P}msctls_progress32Progress1P}Installation progress:PhnPA@H{SetupMS Sans SerifP}
Click the Finish button to exit the Setup wizard.PhnP}(
  
    
      
    
  
PAPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGXXPADDINGPADDINGX././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/wininst-9.0-amd64.exe0000644000175100001730000066600014467657412025117 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$ooo{ *o=8o=)oєoPKuA}PKuN .HcHHD$PFFIEH;T$HIUHHcHH$HDII+HD$p
HA:uH3H$H$HHр|\HT$`tH$HlafGH$
]HcHHD$hHD$@H8tBLI9HT$PH3HLAI	1-HL$@IMILI9uMEHT$PH$.zLd$`H$,H3H$H|$hHB|!\Ld$Xt\FDNLd$0fD$(FH$L3fD$ Ht*NEEDNHT$pLd$(L$ H
MtEDEOH׹AADAD;T$HLD$xE3HT$@MIJLD$ H^HEYH=>t3H=
'HT$ HIptH
rH
oiHP^GH&HcE3H3DHT$0}>tHT$0H
1^kH
lH]LD$ X3H$@H3wH$`HP_@SHH'H3H$H$Hd$hd$XHd$xHd$PHd$`3HlZyH_H
JlD)XHD$XL$L$HD$@HD$hH^HD$8HD$xHHD$0H$HD$(HD$pHD$ Wu3HD$PL
ӜH
3DHD$ YyH9^SHL$PLD$`HHyH]-HL$PH$HyH]HL$PH$HP8yHZ]H$HtHL$PHPXyH]HT$hHt#HL$PDD$XHyH\HT$xHtHL$PHPHyHx\jLD$pH$A33D$(HD$ UHL$`HH$DP0yGLD$pH
mjH[DEVHL$`HtHPHL$PHtHP?XOHL$`HPHL$PHPXH
ZhH$H3QtH[LHHIKHMK IKMCH\HUu3-VDL$`LD$hHT$0H0WH
\YhHHH
="H%eH\$WHH$H3H$HLKhHl\H$D$ ^VH$HTHD
pgD-eH[HL$0VLL$ L$HT$0HQt'LL$ L$HT$0HQt3K3HH$HWHfG3H$3ɊHDuH$ZSH$H3rH$Hİ_H\$UVWATAUAVAWH H
\HSH[HH	SH[HLRH[HHRHt[HLRHI[HHHD$hRH![HLRHZHLR3HD$pH;H;L;L;H;L;L;H
ZHH;t[HlZHHXZHHfcH-m!HHgHc3HHAHHLAH rHl$hHD$pH-eL%RHb3L-RH\$`H A_A^A]A\_^]@UATAUAVAWHHl$ HHHH!H3HEXHHZIMcLHMJQHZIHE6QHZIL#QH\ZIHEQHYILPHYIHPHbYIHE PHMH:YLP3H9ML;H9ML;}H;tL;kH;bH9M XH;H8@3Hu ՂH^YLHH`袀FH
dL$Y	SUHML-63IAhIE~2MLL+HHtT3IHIuDL-D6IAA3H~ILHt!wHH;|HU(λ{uPDEJLRHT$ HA0JyH
G]HtHRL$XxH$X.HtBH=lRHu/H$X' H
\HtL$XH"R5xH$ H3gH8_^HHXHhHp WH@H`E3H@EA@GHHu3iHT$`HmFHd$(d$ E33HEAGHHrGHtHd$ E3E3AQHcGHHGG.HH\$PHl$XHt$hH@_H\$WH0H=GHtQH=[uGILGd$(EH
IPHMAHHT$ DHHH[\IH\$@H0_@SUVWATAUAVH`HH3H$PL$E3+TM+TMuM1"HcHف|PK;{V4tHP3A;D9stHcCHH+HcCH+H
F+SH{+HAHcH+mHI;HT$@4DA;HLPHL$@LE3DA;tgDE3Lt$0AHHfDt$(fDt$ HI;tPLcHHzH3HHHcHIEI4$6E9EHO3H$PH3AdH`A^A]A\_^][HhHL$0GHL$0GHL$0E3E33D$ mGuHh@SUVWHHH3H$HtG&HT$pGHFE3ɋиgfffE33H
&OHL$h3ɉL$`L$XL$PL$HL$@L$8L$0D$(D$ BHHBHHAH3H=@L
@PHDHɉL$ HAHAH3P
H=Y@L
R@DHHɉL$ HAHH~AHAHT$pHE3H$H3bH_^][H\$Ht$H|$ AT0H+HSH3H$HUH33D$`HD$ht$tt$pgA3H$HD$x%EH$@L%MHL$`L$H$H$Df;uH
|SLMHvME3DHVMH$L]D3@HDDHt$XH\$PHt$HHt$@|$8D$0L$E3I3ɉt$(t$ `DHȺHCHVDHH$H3aL$I[Is I{(IA\H\$WH@HT$0HC3 DDL$0DT$HKHL$0BLD$0HYCLzAHDCLSH/C'Ay8uBAE3HȺpvB3H$0H3\_H@[H\$Hl$ VWATH`H4H3H$PHHD$HILHKAE3HHD$ 3=t3H!t$8H!t$0H!t$(H!t$ D$@P31D$@PHt-?t(HT$`HH+DA+uHEuLD$`H5KH$GALD$`HJH$-AL\$PH$AE3HL\$ <ufD$DHHtZHL$PHD$DE3HD$(E33H\$ y<u4L$E3IlAL˺ILcHQAHL$P&<Hd$8Hd$0Hd$(Hd$ HL$HLL$@LD$`;HL$H;H$PH3_]L$`I[0Ik8IA\_^H\$WH0HD$@HAE3HHD$ ;3ۋ;uHL$@p;;ËH\$HH0_@SH H?HH;tKH=uu:H1LIHIA?VHHHH
H [̃~HtuHg}H
Hl$Ht$H|$ AUAVAWP*H+H3
H3H$@NH3t+fD;IfD;9HQH;tE3ɺArHD$ >H΋>L5MHHMIH~>MHH,E3AHH|$ [>L;t!tHALcHH|$ 3>M@:t4H	IH$@M=L$@H>LD;uD@:t"H{HH$@M=H$@H)HLHAH=H=AE3HMͺp=E3AHH|$ o=HLu\f=EME3HȺpY=L@H=L@H=@N:
=ME3HȺp<McAHMH|$ <L=sNHIH
"H+ЊH@:uMǺH9=MAHH|$ <Hc:bLH;tgMAHHD$ U<L
^MLKHFI|ru"D
E3HH/HL$H*HTH\$@Hl$PHt$XH0_H\$Hl$Ht$ WH0H[HHlEHHHH]REHHHH=5EHH
2HD$HHWAE3HD$ M*t.L,;E3HH.?HL$HHS)t!tM.Lv=E3HH.HL$H)HxSH\$@Hl$PHt$XH0_@SH :tDHHtH荇uH+H [@SH :E3E33,HrH==t	H=HHH=~HHu	Hz=몹PQHHD$8HuHJ=3SNHL$PLƺlHH3H|$PHHHcHLIE;|$A
HIcHHHD$8HJHL$PLƺɏH]DHbMcL
IAH‹LC<H;A$3+CE3HHP.MJHT$  t
A$%H.BH
BHAHE A$AE+AD}H+D+D+HGAHEI@DuHEAET$D#AD$@H8A_A^A]A\_^][3H;tXHQ(H;tOBAAHA ALBBHB B,B0B4B@BDHHHHB`HBX3BøEHt:LI(Mt1,EADEA wʸEQDAA#AA@3øH\$WH HMA81AXHu
Ha Hy0uHa@HHA0Hy8uHHA8HI@AH%S0HHuBRHC(y`0B}GwHb8Hˉz(HK@S8Hc(\H\$0H _ELºH!@Ah	AlHAXHHHA`H\$Hl$Ht$WH HY(HH{8u!K(DHN@V0HC8Hu{,uK(c4c0{,+n{,HV;rHK8LH+!c4C,P+{4K4;GHK8H+D!+tHVHK8DI+!k4ËK,{49K4uc4C0;sljC03H\$0Hl$8Ht$@H _ÉT$SUVWATAUAVAWHXE3LI;Hy(I;L9aL9!u
D9a?uDIDqLQL9Dt$8ED$D$wDo@D$LT$@AG;A;t__HXA_A^A]A\_^][E;AAIA;r߉o@tHGtHGHO I;t
g	s#@l$0HT$0@l$1OA5GAAE;fAAI rHG I;thg	s5@l$0HT$0AD$1@l$3D$2OGAAAE;AAIA;rHO I;t@ʼnAHG Hg	s)@l$0HT$0@l$1OACAGAAg
r{HG I;tL`g
_HA;AGA;HG I;LHM;PH+WH;vi+gE;
AAIA;rHG oHI;thg	s#@l$0HT$0@l$1OAqGAAIDIIg	sODI3ɉ$;txD$LT$@H;IE "G|fDGG|A;uGxGt9G|DD$D$H:IE HDGxHOlHG`GtLd$(HL$ LHGzD$D$LT$@$E3䉄$A;tH:IE ArGAr>MUEMM}EuAI͉o@wDMUEMM}EuD$#OhL_XAAA+ȋH#A5E;AAOhMAA+ȋH#HGX;wA:DȋAD$4EAAAAD#ADCDADYE;ADL$5AAD$6AAAAIǃD#ADHGXBDED;wL$5++OHA:u p@tH:/OPWPA;t9;s!E;8A΃AI;wPrߋʸ#GH+OlL_`AAA+ȋH#A5E;AAOlMAA+ȋH#HG`;wDȋAD$4EAAAAD#ADCDADYE;PADL$5AAD$6AAAAIǃD#ADHG`BDED;wL$5++@tH-qD$D$LT$@AOLȃOPWPA;t9;s!E;A΃AI;wPrߋʸ#GL+G0A+A9GLvH,E;:OLAA+;v/+ȋG4;vW,++H5+ЋGHHW8;v
	GHIH+ыA;AGD++GHD$HAIƒuLT$@QD9gHFnGt.pidD9gE;dAAI rE+EEDGE;t;OAIH+D9gtD$LT$@GDZ	AEL͋ED$ȋ%ȋD9gE;OtH4AAD9gD9gE;AAI r;ot]H4lE;t`GHAIAD$LT$@MUEMM}Euo@wDAAAAD$HD$@$M}IE$EuAEo@3wD9o,u?}A;]tI;t!A+]t$8A+uA]Au_9ot+;t'IUOH+D9ot GAELG؋Ƀ@?DODAMH;u;t
$uD;DDA@SH HHt6HA(Ht-LA8Mt$HP8HtHI@AHS(HK@S8Hc(3H [H\$Hl$Ht$WH AHHHtHY(Ht{t;
tH\$0Hl$8Ht$@H _Ã;
u%E333DHՋ;CtWHCt
HK8;s,vDC,HI+HWD[,D[0C,H+LHH9s0C3[HtHA(Ht@tHP b@3øD	E3LEttMFDE3ȃf@+FDrHL$0F@FDn@AH~DsHN|HT$0!DGHHN|G)GDOH~|t#DGHDODG3H\$8Ht$@H _3H;tHI(H;t9
u9ADuøH\$Hl$Ht$WATAUH HLH=H4Hz(H'HB0HHz8HK@AAH%AHHu
3H9o8t&O(AEHK@S0HHuHK@HS8IHAXAH%HHL_XHHHL;rعƕH [H\$Ht$WH0HH3ۋH;;u"X{8H\$ E3E333G-荖HH;tDXLH\$@Ht$HH0_̉L$SVWATAUAVAWHHHc3ۋH;;u.XWH\$ E3E3338G3DB0HJuWW	;t;5ihLLIL=fAMkXKBL AA#u.xWQW	H\$ E3E333F5耗KFt!uW	J!A;t1t,;uV	Wu fO	fO7wfDwf_f_f_
H_(H_ H_u_FKH\$(H$HD$ E3E33J!#$Of_f_f_
f_fDwKHT$PJ!;u@VDt$PtG
$fG
G
fG9\$du9\$huH_ nH$HL$d,;wHT$@H$	;\D$LDT$JDL$HDD$FT$BL$@L$0D$(DT$ 蕙HG 9\$\u9\$`u
HG HGnH$HL$\;HT$@H$;D$LDT$JDL$HDD$FT$BL$@L$0D$(DT$ HG9\$Tu9\$Xu
HG HG(fH$HL$T$;tiHT$@H$;tRD$LDT$JDL$HDD$FT$BL$@L$0D$(DT$ 蕘HG(D$tGGfG_
')>TT	H\$ E3E333aCHĐA_A^A]A\_^[HHPHHL@LH SVWATH8H3ۋH;;u'SH\$ E3E333BH;;u'}SH\$ E3E333BLd$pG@Hƪt*t%HcHHLHkXIH
=H
4HLB8u%ttHcHHHkXIA8t"RH\$ E3E333B;u*HME3HT$hH0H׋謝H[H8A\_^[LD$LL$ H(LL$H蠫H(LD$LL$ H(LL$H褫H(HHPL@LH H(LHE3}H(LD$LL$ H(LL$H脫H(HHPL@LH H(LHE3]H(Hٝ@SH u;LHcȺ耈HHu$PHˉcHHux3HkHH0HHt	HjE3HbEHILIHIHkXLItItMuIH0Iu3H [H(蟭=ltH
H(@SH HH
H;r:H@H;w.HH*H+HHHH?L蜎k
HK0H [@SH H}nk
HJ0H [H(H1H;r7HH;w+qH+H*HHHH?L
H0sH(H(}rƌ
HJ0JH(LD$LL$ SWHhIHMu%tOHd$ E3E333>iHtHtѹL$D$HBH;H|$@H|$0GHL$0E3T$8H豛Htl$8x
HD$0HT$03ɫHh_[LL$ H8HD$`HD$ H8ffLMt$H+t(HItuIHHHIr&I~LLIM3IMtIHItx$tuHItiHtbHItV$tSHItGHt@HIt4$t1HIt%tHIt$tHIAA	A
AE+t\AND;u2AH3;|	
>E3E333H\$ $.3H\$PHl$XHt$`H|$hH0A^A]A\3A9X|AxIcHHD$xHHL$pDD:FIIDM1H	H9u-3A9XhKA9H[IcHHD$xHT8HL$pDD:IIDM1H	H9uI%HD$pM1HAH3;*ЍR+ȍCDAMD+At\At7E;HD$xQHHD$(HD$pHD$ H3;4A@3;h;`;tH3A9XKA9HAAHA9X3Axm%A9H|+E@$IAAЋ‹kD+D;|Aދ3A9A8;AH3;;Ax|;Ax1E@QAЋJkdD+kdAP<3oAmAZA/E+E+tdE+t/D;DAH3;mSAHA;|$LL$pLljD$ dLl$xLd$p3Ll$(Ld$ 9$tIAp;I9$HLl$(L L7I$Ld$ LƺH433A9X\AxQIcHHD$xHTpHL$pDD:IIDM1H	H9u3A9XKA9HIcHHD$xHHL$pDD:IIDM1H	H9u~AH3;ApAE+t|E+tNE;4:39^ HHHL$pDD:
HIDL7H	H9uAH3;-Qkd+HD$x3HD$(HD$pHD$ 9$tAu3n3A9XKA9HNA3A9XAxAxHD$x,H0HL$pDD:t@IIDM1H	H9u*L8HT$pED:tHMD	L7H
H9uA`@UATAUAVAWHpHl$@H]`HuhH}pHH3HE LMLEME3LHMAA;tA;t	IPIHI@E9\aAAL-FLE-3lDD$(fAXfDEfEAALD$ fALE3fE
AAfEAAfEAAfEALfEAE3DA;=:HHHH;w
HHH苡H+H\$@I;HcE3HI;t
HI;tiAXLEL3Dd$(HH\$ ADXE~%HH:vIAˈIH
HEHK9uLMLmAA:pHL9`AAILMAIA8$tDAdg1A'AAtAHtYAMt#AaHH^uOLg`A+t!A+tA+tA;QBbA۲mA+t
A;t*A۲HiHLHuLgpKAtxHE3A:uL9X<'tRI3E3EXA;tL9vD8G>IHLjMHIIMHA:uIHcHE3A+t!A+tA+tA;_AaA۲dAЃh1A+t%t
YOyHAy	I0I8E3A;L9I'E3EXA;tL9vD8C2IHÈMHIMHL9IE3EXA;tL9vD8CIHÈMHIIۈMHA:uA+tA;t$A۲SfA+tA;tA۲MSA+tIA;tGIATE3EXA;tL9vD8GtcIHLjMHIIMH1A۲ILE\$0MIL|$(Ht$ mE3A;tEXIA:t
LM3AHM H3H]`HuhH}pHe0A_A^A]A\]HHXHhHHVWATAUAVHpHH$LHHE3MIAL$M;sI;jE3I;^H$I;uHD$HHXHI;HD$@A:%tsHT$HA;t;H|$@v3D8sH$HÈH$HHL$@H$H$HÈHD$@H$HHD$@SM;HAƀ;#uHÊD$0HD$@L$HL$HMHl$(HD$ A;tHD$@HI;L9t$@vE4$A;uAL9t$@w:2"LI;vH$D1H+|$@D8t$`tHL$XH41E3E333Lt$ !D8t$`tHD$X3L\$pI[8Ik@IA^A]A\_^H8HD$`HD$(Hd$ H8H8Hd$(Hd$ H8H8HD$`Hd$(HD$ H8H\$Ht$H|$ ATH@Hd$0EHH3Hu'0Hd$ E3E333A 33Hu'0Hd$ E3E333 338u$0Hd$ E3E3333gKHHD$PHu]03F>u"I0HHL$03LEHH/HHHH\$XHt$`H|$hH@A\A@@SH0ILHHu%/Hd$ E3E333ɉ$AHIrHHt3/H0[HT$LD$LL$ SH`Hu%f/Hd$ E3E333UHtHL$@HL$0L$HL$0E3D$8D$HB{l$8x
HL$0HT$03ϋH`[LD$LL$ H(LL$HH(LMCMK H8IC E3IC	H8LL$ H8HD$`HD$ H8LMK H8IC(ICIc_H8LH8IC0ICIC(IC<H8LMCMK H8IC E3ICH8LL$ H8HD$`HD$ H8HHHHPL@LH H(HPH(HHHHPL@LH H(HPH(HHPL@LH H(L@LH(HHPL@LH H(L@XH(@SH@HcHL$ HD$ ~LD$ RDH@DXA|$8tHD$0AH@[@SH@=HcuHX%YHL$ 3HD$ ~LD$ IRDH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ QDH@DXA|$8tHD$0AH@[@SH@=/HcuHXVHL$ 3"HD$ ~LD$ cQDH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ PDH@DXA|$8tHD$0AH@[@SH@=KHcuH/XVHL$ 3>HD$ ~LD$ PDH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ PDH@DXA|$8tHD$0AH@[@SH@=gHcuHKXVHL$ 3ZHD$ ~LD$ ODH@DXA|$8tHD$0AH@[@SH@HcHL$ HD$ ~LD$ 6ODH@DXA|$8tHD$0AH@[@SH@=HcuHcX%YHL$ 3pHD$ ~LD$ NDH@DXA|$8tHD$0AH@[@SH@HcHL$ 	HD$ ~LD$ JNDH@DXA|$8tHD$0AH@[@SH@=HcuH{XVHL$ 3HD$ ~LD$ MDH@DXA|$8tHD$0AH@[@SH@HcHL$ %HD$ ~LD$ fMDH@DXA|$8tHD$0AH@[@SH@=HcuHXVHL$ 3HD$ ~LD$ LDH@DXA|$8tHD$0AH@[@SH@HcHL$ AHD$ ~LD$ LDH@DXA|$8tHD$0AH@[@SH@=˗HcuHX%YHL$ 3HD$ ~LD$ KDH@DXA|$8tHD$0AH@[@SH@HcHL$ UHD$ ~LD$ WKDH@DXAW|$8tHD$0AH@[@SH@=ߖHcuHX%WYHL$ 3HD$ ~LD$ WKDH@DXAW|$8tHD$0AH@[@SH@HcHL$ iHD$ ~LD$ JDH@DXA|$8tHD$0AH@[@SH@=HcuH~X%YHL$ 3HD$ ~LD$ %JDH@DXA|$8tHD$0AH@[@SH@HcHL$ }HD$ ~LD$  IDH@DXA |$8tHD$0AH@[@SH@=HcuH}X VHL$ 3HD$ ~LD$  ?IDH@DXA |$8tHD$0AH@[3Ã@SH@HcHL$ HD$ ~LD$ HDH@DXA38L$8tHD$0D;u_uH@[@SH 3;u_uH [@SH@HcHL$ HD$ ~LD$ &HDH@DXA38L$8tHD$0D;u_uH@[@SH 3;u_uH [H;t$MtfDD	HˆDJHIuH;Hl$ WATAUH H\$@Ht$HLt$PN4MIHLffIIL;wDHHAՅHOHH;vLHH;t%Ht H+fDHIDJuH+I;wLt$PHt$HH\$@Hl$XH A]A\_@UATAVAWHMILHu6Ht1 E3E3E333L|$ DHA_A^A\]MtMtHH$@H$HH$PL$LjLLE3fff3II+HHpHw*MLIIzINt0N HIHIHAԅ~3LHL;t(ML+fAHIADJuIIAԅ~3LIM;t(MM+fAHIADJuIHAԅ~3LII;t(LM+fAHIADJuIIH;vHH;sHHAԅ~H;wHI;w
HHAԅ~H+H;v
HHAԅH;r7LHH;tLL+AHIADJuH;uHzHH;s"fH+H;vHHAԅtH;rfDH+I;v
HHAԅtIHH+I+H;|&L;sNt0J II;"LI;sJ\0N IL;LH$PH$HH$@L$HA_A^A\]H\$Ht$WH HHHu
HjHu*\HwCH
7HHDL3LHHuo97tPHHt+HvHG3H\$0Ht$8H _}HX%dH?H@SVWATAUH@I؋LLHHu*t&$H!t$ E3E333n33u'Hd$ E3E333<3Y3Hu'Hd$ E3E333	3&u3H$HC@Hst*t%HcHHLAHkXIH
ozH
fzHLB8u%ttHcHHHkXIA8t'Hd$ E3E333I3Ht$0HtV|$xtHCxHHH
H蔹ȉL$puM;u3Ht$0A$ILd$8
tA$H[HH@A]A\_^[ffMtuH+LItB	H:uWItNtJHuJ	ffwHJ	H;uHII~vHLI3ItH3HHÄt't#HttHtttuH3H\$WH HNH=`wHtH\$0H _@SH CAH
k<H [H@SH H
זHtHHHtH [@SH ̹W̹VH;s-H\$WH HHHHtHH;rH\$0H _H\$WH 3HHH;suHHtHH;rH\$0H _H8Hu'>Hd$ E3E333HHtH3H8H8Hu'Hd$ E3E333?HaHtH3H8H\$WH H=ΫtH
ëVt腺HH
_uZH
/ڹH3H=4HHtHH;rH=gtH
^tE33APF3H\$0H _H\$Ht$DD$WATAUAVAWH@EDV=nD%cH
Ī9HHD$0HH
r9HHD$ LHt$(LHD$8HH|$ H;r;9H9uH;r\H39H9HH
O9HH
89L;uL;t LH\$(HH\$0LHD$8HHD$ H(H
,H%H
Et
SEu&bAL$SA|AoH\$pHt$xH@A_A^A]A\_E33jE3AP\33DBO̺3D=@SH 8HH@HBHH*H.H辻H膹HbH
7H3gH [@SH =uj?=H [MZf9u9Hc
GHHȁ9PEu f9Au3v93H\$Ht$WHHL$0/MZf9ubHcH5HƁ8PEt3ۉ$Nf9Ht3ۉ$8w3ۉ$$39É$3ۉ$H56;u!9=xuM>;9u!9=Nu#>;\[y
,HEtH~py
Uy
	Tt@|$lT$pA
DEL3HtD$ uNa$u@VL$I[Is I_H(gH(HL$HH
~{LL\$XE3HT$`HL$XuHD$PH|$PtAHD$8HD$HHD$0HD$@HD$(H|~HD$ LL$PLD$XHT$`3cu"H$HHH$HH~H.H}H$H~v}	p}H^HD$hH^HD$p}
3fH
Q=}u
	H"HĈH
a@SHd$pHL$t3A萦L\$pH$H$L\$HHD$PH$HT$@HE3;tHt;Hd$8HT$@HL$`HL$0HL$XLHL$(H$LHL$ 3s H$H$H$H$H$D$pD$tH$E3ɋ3HL$H uuHHH[H\$WH HH
$2HH2H
HH\$0H _H
2H8HD$`HD$ }H8H\$Hl$Ht$WH0HH
AIHT2HtLT$`DLHHLT$ %L\$`DLHHL\$ H\$@Hl$HHt$PH0_H8Hd$ E3E333_H8H8HD$`HD$ EH8@SH gH [@SH WH [@SH GH [HSVWATAUAVAWHPE3EADpDpDpANMLH$
A;tLt$ E3E333H$8
A;tLt$ E3E333H$R
A;tLt$ E3E333TD5AD=<`D=%`H
IHHD$@I;D80H
I;t HHhA;u	AwH
sI;t襱HGHHDHQI;u
HFLHPH
,DA;xLt$ E3E333_H
~I;t0L5~H
6~,~
~k<$fD95K~tQ~k<ȉ$;~fD95y~t$~A;tDŽ$+k<$D$D$H$HD$8Lt$0?t$(I$HD$ EL}3ҋIA;tD9$u
I$Dp?I$D0H$HD$8Lt$0t$(ID$HD$ EL}3ҋA;tD9$uID$Dp?ID$D0$F$($"IA;gAMLAW=I$HA;tLt$ E3E333I?-u	AHHDEiD$0@9<+:|	@:?:ulHHkH\$@Hl$HHt$PH|$XH0A\H\$Ht$WH0IHH?!tHd$ E3E333"HC@8tL
AHHHD$ H8tL
AHHHD$ H\$@Ht$HH0_H\$UVWATAUAVAWH0HAUAF!HH$3H;HnLkhED$ED&IEL
jHD$(HfQHHD$  MLL5;3L6QH;tE3E333Ht$ I$IMQA;HEIIMII HLlHIEHD$(HHD$ LM;pH$E3A;uHHKXI;tu	HKXΌHS`I;t
u	HK`貌HsXHkHHRH蝌HKXI;tu	HKX~HS`I;t
u	HK`bHLkXLkHLkPLk`H\$pH0A_A^A]A\_^]@SUVWATAUAVAWHH4H3H$H$`IMHH-HpLhE3HL$@HtLt$0LHL$8I;I;M;;CuTD8cuNLRIH7A;tE3E333Ld$ I;tfD'fDgfDgI;tD&H;H LH=s(HIٟHL$8HğHL$PHE3HT$0LD$PHL$PHD$0HL$@LD$P@ID83tIsMHiHL$8MNLúNtHd$ E3E333Lt$0HtAIH|HtHT$@AH|MIHtHd$ E3E333I3H$H3܁HA_A^A]A\_^][H\$ UVWATAUAVAWHH2H3H$ILcH	LL$HHT$pHHD$@AHD|$(HD$ _Hu3oIHL$pHHT;HLHL$pHHHLHtHD;HMoHL$hHD$XBAD$PKDHGHHD$`h{GHULD$pIL$D$DtHd$ E3E333HL$`ID$HT$HHD;HD$HAB
{AD$@E33҉GH|9Gt!H|H|HAHH|EtIcH|H|H|AGAhzD$8D$0GLMD$(H$UD3HD$ KtCH$f!HHuHj=H$A'3ɅG|AuD$@GKH4H…HD$Xt"IHD;HtD\$PD$DFGH
<H;t)HT;XuHL;X>IIL=0Hd;PA$Ld;XHD;HH$H3~H$hHA_A^A]A\_^]@SUVWATAUAVHH/H3H$IHt Ht
IHcHHDH83DfH$A8LAAxC6Ax_+H$H|HHLL+x8;oAL%I$MHuI$zL;tHIAL;~HHH褿HHu
};
AJHL$0LLź{tHd$ E3E333JLD$0AHD0HtH݀;tHÀ;HJH$H3*}HA^A]A\_^][!t$(H!t$ HT$0E3AHHt3HoHt-HUHL$0謙tLD$0HHuE3H ~EgZ3cHHXHhHpHx ATH Hw+Ht&AIAL$MHHu(H3H\$0Hl$8Ht$@H|$HH A\IԹ`HHu
H@IԹ HCHu
H H;Ht%H9H;tHA`Pv'HHLƋHtHHSHdt%HKÃH[H?H諃3HCD HCD HHt$H|$Ld$ AUAVAWH@LDE3v&$L!d$ E3E333n3nHHD$p`HHxHHtH;tHA`1u'HMAHLHD$0HMt)H08I8
PAAE͉
pPAfHHHD-7HH
.9H"9HAH
	P\tL9ACPACPA8IXH/I(Hp>I@H=A]>{H5IHt$`H|$hLd$xH@A_A^A]H%}[3H%s[H%q[H%q[H%q[̋Z83H%e[H(
B8t
W[
08H([H\$WH HHHMHAǁƁtCƁCH1H
H
qHHuH{7HHl5H\$0H _H\$WH X
Z7bZHHuHHHHt3
/7H>ZH˅t3:ZHK3ۋXHH\$0H _@SH qHHuHHH [H+H\$WH HHI8HtHKHHtrHKXHtdHKhHtVHKpHtHHKxHt:HHt)HHH;t
HHL$0HtuHA$H;=Y>utHAI;uI]HL9'uHc
HHI;u	4HHHHHI;u勌$L#$H==I;H=A;tKI;tFdH= A;}|NA;trH$H@A_A^A]A\_^]A;t3I;u%k	HL=I;tL H=M=I;u F	H7=I;tL H=(=HI;tHM+3IHMcH;tCy=MHI3;uHfB9<`fB9`HHH;uH=<H+H;CH9:HcHUuD$3D;tjH9tHL3HHHHH9uHcHH;s=H
V<A	3H;t&H=<H=4<H+HjLG؋H [Ë=
=H\$Hl$Ht$WH 3HHmHHu(9=v FDD;=AG;uHl$8Ht$@HH\$0H _HHXHhHpHx ATH 3HHAE3HH)HHu*9G=v"EDD;/=AAGA;uHl$8Ht$@H|$HHH\$0H A\HHXHhHpHx ATH 3HHAHH4HHu/Ht*9<v"EDD;<AAGA;uHl$8Ht$@H|$HHH\$0H A\H\$Hl$Ht$WATAUH 3IHALLHI˼HHu/Ht*94<v"vDDD;<AAGA;uHl$HHt$PHH\$@H A]A\_ffHHHtfHt_uI~IHMHLHI3I#tHPtQtGHt9t/Ht!tt
uHDHDHDHDHDHDHDHD3Ht9tHHH;rH\$Ht$WHPHًHL$0Ie3H;uDsE3E333Ht$ 轵@8t$HtHD$@3H\$`Ht$hHP_HT$89ruH|Z@8t$HtHL$@f;t3DtH@83t;u
HC;tH;l@8t$HtHD$@HfE3HHXHhHp HPWATAUAVAWH@MyM!Iq8M+AfMHL3HHL@9>+H^CL;CL;{;tHL$0HIЅ~sA}csmu(H=WtH
WgtIWKAHIO]IF@SMcMHD$(IF(IMHHD$ @R]H;>sj>3fIy 3I+9.vTH^KL;r>CL;s6H;rH;sAE u/;t	H;t#HT$xIDZIDCMAH;.rL\$@I[0Ik@IsHIA_A^A]A\_H\$Ht$H|$ATH L%33I܃{u%HcƺHHJ8HHrt-H!HH;|øH\$0Ht$8H|$@H A\HcHI$3H\$Hl$Ht$WH HAH-z!HH7HttHx?HdfH'HH;|HHt{uO?HH;|H\$0Hl$8Ht$@H _HcHHHH%x?H(H3?H(˨H\$Ht$H|$AUH HcپH=3u(N芨HHL-UI|t{(HHuF3Z
fI|u/HH\$0Ht$8H|$@H A]H\$WH HcH=HH<uuHEHH\$0H _H%$>H\$Hl$Ht$WH Hڅxi;
?RsaHcH-GRHHHkXHDH<u==u'ttu5;HDH3	 H\$0Hl$8Ht$@H _H\$Hl$WH xs;
QskHcH-QHHHkXHDDtGH<t@=u)ttu3:HDH3M	b H\$0Hl$8H _H8u> 	]x1;
Ps)HcH
PHƒHHkXHDtH, ̿Hd$ E3E333	HH8HHXHpHxL` AUH HcLIL-jPHkXKt|3u3O	|3uHL3gn#D3
GtKLHL;H\$0Ht$8H|$@Ld$HH A]HcH
OHƒHHkXHHLH%|;H\$H|$Ld$AUAVAWH@IEE3AL$uA3|$$HsO@LcJHH\$0JHH;C{u;
p{u HKGmuDpDt$(C
Eu HK:CtHK:HIEu?CL#LNK+H.袋.HLIIH?LDDl$ HXH\$0IHzN E;lj|$$H_NXJYHD$0HttHcL9NIЃN IHH;s@L @	
`HXHD$0|$ HcHHHkXIDHADD|$ AH\$`H|$hLd$pH@A_A^A]HHXHpHx ATH0L3x@ߍG Esˀy9;uV8諼u@utHct$Hu;P8PIԋHHHLLHkXIȈ\IȀd8IȀd8D$ H\$@Ht$PH|$XH0A\HHXHhVWATAUAVH````McHcFZLNFBA8Lc$A;&Lc$A;A
H
iAQDLA+A;}[Ùƒ;uAkd;u#lAiҐ;AC,ƒ;uAkd;ulAiҐ;u~ō+ADCDAAADAAD+ʙALHcHFHcHimHHcHHRItkH>teAEt^AEuH3A;tILcIHAMkXM$HI$AEAD$IL$FfA;tAD$IH;|EIHHkXHGH;tH;tKCAD$ɃE;D0HHtJI;tEH;3A;t7H3uK@	uKHKeA;tC.K@HAHHQ
"Gx23L$I[ Is(I{0Mc8IA_A^A]H\$WH HFH;Ht7Ht
HO*2HHXHH;rHYH#HHHH;|H\$0H _H\$H|$ATH H
-cH0H;u3cH`H;uwCucL%,HcI<u+IHuHC HCHC$CIC$CHKHK3H\$0H|$8H A\̅t0SH bHsHcc$H#HcH [@SH B@ItHzuA&Bx
HHFu	H [̅~LH\$Hl$Ht$WH II@LH@?tH\$0Hl$8Ht$@H _H\$Hl$Ht$WH A@@IIHtIxuA7~3MLHHŃ?u豳8*uLHֱ?H\$0Hl$8Ht$@H _HH@HHH@HHf@H\$UVWATAUAVAWHHNH3H$3HHL$hHHL$xIMD$`DD$TDD$HD$XD$P@RE3I;uA3E3E333H\$ ;8$tH$AC@L
H"
HA;t(t#LcL
IAHMkXMɀ
LL
ȻA@8u)A;ttHcHƒHHkXIB8tA'3E3E333H\$ o8$tH$A1E3I;t@/ADT$@DT$DAL$A:H$AHA;H$E8B8u%ttHcHHHkXIA8t""H\$ E3E333l;u(HMLL$pMIHA֋H׋HVH\$PHt$`H|$hH0A^A]A\H8LL$ MLHH
;VH8H8LL$ MLHH
O2H8H8LL$ MLHH
H8H8LD$ LHH
E3H8H8LD$ LHH
E3H8H8LD$ LHH
JE3H8H\$Ht$ATH03N^\$ ;I}iLcH8J<tPJAt>[tƉt$$|1H8JH0!H
8JHL8K$É\$ 돹SH\$@Ht$HH0A\H\$Ht$WH A3H$<u?At69+y~-HSDNj3;uCyCK HKcHt$8HH\$0H _@SH HHu5,jtcsH/3H [Ht$H|$Ld$AUAVAWH0DE33Ns3|$ A;=zGLcHR7J<tjJBt`SH27JAt5Au9A;t%ADd$$EuAtA;ADt$(H6JSlj|$ nAADHt$PH|$XLd$`H0A_A^A]H\$HL$WH HHuRHHSH\$8H _̹HHXHhHp HWH HHKHcu	K 4@t
֢"3t{HCHKC{Cu/PH0H;tPH`H;u;uHC+HS+kHBHC$;C~Dŋ1W K?t#tHHH2HHkXHH
$A t3ҋDBIHHKD$0HT$0D0;D$0H\$8Hl$@Ht$HH _H\$Ht$WH IIHH;
udM9u=H]HHu3KHD$PHLH6LML"HHA(HtHHHHH\$0Ht$8H _HH(@SH v˃߃EˋH [H(AxHHH>ЋH(H(t肿H(H\$Ht$WH HHH؃twuHt$8H\$0H _H\$UVWATAUAVAWHH6H3H$pE3L$L$IHHT$PLd$pHHL$`HDŽ$^D|$|fD|$xAD|$EAD|$9ED|$4\$lA:A%SvA;tXD+DHDl$4A;t%vA;uH֋~HMvA;uHl$PD8ekD8eP3D|$\D$D|$LAED|$XD|$@D|$0AD$L|$P@D\$8LAs3;tvCDDlCлL$0@:t҉|$h|$HD$pL$LD$p@<HD$|HH$HHD$ JA;p	+u$Ź+A;uADID$<@`Ź+A;t\HD$pL$@<HHD$|LD$pH$HHD$ A;IAD$<mA;uD+Dl$4A;tIԋA;D8|$0u7Ht$pD$lD<3\$8H
+͹H$L$LƋHl$PA;uD\$hA@:Hl$PEApAsAuAxA{tBHl$PE;T$9Dl$4E3AֈT$9A: L$L$@:Hl$PEDOH}^uHDt$X3H$DB +}]AuA]IƄ$ E<]E3I<-uVE:tQM]tIID:sDEDE:w,EAMAӃIEMBE:vE DDAIBE<]xA38]+uA+t$H;ADd$4Hl$`0uOEHDd$4/D$<@g3;tgD$\@D$\ft$\3Ƀ߃;E|$<t>3L$Lt$\9D$ht+t6\$4Iω\$4D$@OUtqH$@OTH$3Ƀ;E|$D$X|$`t$\tD+t3H\$hD$4HJD${E3E333Lt$ ZjD8$tH$D$d\$dD8$tH$H$pH3H$HĀA_A^A]A\_^]H\$WH HcLHtYHWu	@u
;u@`tHH;tH#u
3ۋ8LHHAH
HMkXBDt"z3H\$0H _H\$Ht$ L$WATAUH0Hcكuy38y	3;;]
HLIL-Z
HkXKDL0u+sy8Ly	H|$ E3E333ha~KDD0t	y	)y8x	H|$ E3E3333hH\$`Ht$hH0A]A\_@SH AHt"AtHIc3HHCCH [H\$ UVWATAUAVAW0H+HhH3H$ 33ELHcىl$@Eu3Hu.Jx!8#xH!|$ E3E333mgLLHIAJLt$PMkXAt8@@@t@u	AШtAD t
3ҋDBvCmHJAD3HT$XHHV9YJIt	@g!|$LI܉D$XEwDt$X
@HT$PE3
H-HTAA|Pt ADLL$]AD$\AdPHT$\I#t4IH+IHHL$DAH荘vHAHHL$DlUHd$8Hd$0L$XHD$\LD$DA3D$(HHD$ _HD$PHd$ H
HLL$LHT$\IDBA+|$@9l$L
EHD$PHd$ @l$\H
LL$LDEHHT$\IT|$L|{D$@e@t@uE3f
fD$DAH@t@u6L$DPf;D$DEtfl$D1f;D$DuxD$@A+A;\$LLt$Pl$@zet	uLt$PJLADLJDADP\$L떋\$LHJAD3I@ES
Dt$@H$ 3ɋA+A;s&EH<
uAHHHHHrH!\$ H$ DD+HDt$@Lt$PLL$HH$ JIt5|$HH$ H+HcD$HH;ź
A+A;N@E"
Dt$@H$ 3ɋA+A;s1EHf
ufAHHHfHHrH!\$ H$ DD+H%Dt$@Lt$PLL$HH$ JIJ|$HH$ H+HcD$HH;ź
A+A;?ENA
HL$p3ҋA+A;s.EHf
ufDHHHfHHrHd$8Hd$0HD$p+LD$pD$(U
+3DH$ HD$ iD3HD$PHd$ HcH EH
HLL$HD+Itt$HD;D;A
A+A;IH!|$ LL$HEI[t|$H3~q~HlJAD@tA<$.dqyq H+H$ H3IH$H0A_A^A]A\_^]H\$Ht$L$WATAUAVAWH0ELHcكuq38p	3;;HLIL=HkXKL0u+p8p	H|$ E3E333_mŰKD0tEIՋKp	`p84)Kp8$p	H|$ E3E333n_H\$hHt$pH0A_A^A]A\_@SH@HL$ HD$ DH@BY%|$8tHL$0H@[@SH@HL$ 3HD$ DH@BY%|$8tHL$0H@[Lº;̺Lº̺ΓLº̺鲓Lº̺間Lº˒̺zLº鯒̺^Lº铒̺BLºw̺&LºW[̺W
Lº?̺Lº #̺ Ғ3f;@SH Lº3;uf_uH [@SH }3;uf_uH [@SH Lº蒑3;uf_uH [@SH !3;uf_uH [LEIA@wA 
HAw EtD;tD+AH\$Ht$WHPHHHL$0IBHu:lHd$ E3E333A\|$HtHD$@qHtHD$0xu HHH|$HtOHL$@AHT$0ʑHT$0H踑HDžt;t+؀|$HtHL$@H\$`Ht$hHP_H8=au8Hu')lHd$ E3E333r[HtE3H8H\$Hl$VWATAUAWH0-4IE3E3E3ۀ: EyEHLuI߀; t;at?;rt3;wt'kHd$ E3E333Z393A	IA׊AȃS~to tLA+tBt+
tuEE׃@@@Ew@uqjEu]E׃ ]TtJt:A+t'tAu35Eu(E'EuEAus3IߊEI߀; tH
ZAHHI߀; t;=nI߀; tHjZAHTu
HMHSZAH1u
H*H@ZAHHI߀; t;HL$hEDID$ 谚D=!FD$hH&HfHf(FnHH\$`Hl$pH0A_A]A\_^H\$Ht$WH03ۍK?3|$ ;=JHcH"H<tkH@uV`rOGwOHH\LI@tHЋHlj|$ xHcXH
HH
H<tXHH0duH
mHhL]I$$HOHH0L:IcHtccHcH#Hc(KHH\$@Ht$HH0_ffHM3M3Hd$ LD$(HfDHL$HT$DD$I ff@SH`Hu%0gHd$ E3E333yVJHtHL$@HL$0HL$0D$8D$HB至l$8x
HL$0HT$03H`[ME3uHhHHu%fHd$ E3E333U#Hd$@Hd$0HL$0D$8D$HBHhLHH
E3MLHH
вwLHH
{oE3_MLHH
`oGH\$Hl$Ht$WH`3MIHLL;u'eE3E333H\$ UL;tH;tL$AL;L$HT$@GHT$0HL$0ID$HBD$8AӋH;t7;|%l$8x	HD$0HT$03t9\$8\.ÍCL\$`I[IkIs I_H8LL$(Hd$ MLHH
HH8H8HD$`HD$(LL$ MLHH
UHH8@SH0HMtGHtBHt=HD$`HD$(LL$ MLHH
A`lyu0Sd"FdHd$ E3E333SH0[H8LL$ E3oH8HHXHhHpHx ATH0IIHHMMuHuH3HHI;vPcLFH
q_HD$hLHD$(HD$`HHD$ uonc8"`cTcH
%_LD HD$hLHD$(HD$`HHD$ 0DuHuc8"uC	cD 9y8u-b"bHd$ E3E333/RH\$@Hl$HHt$PH|$XH0A\H8HD$`HD$(Hd$ H8H8LL$(Hd$ MLHH
kpHH8H8HD$`HD$(LL$ MLHH
k8HH8H\$Ht$WH0HHu$bH!|$ E3E333NQA@t AAuMHAHH(DG$HWGGu_HtHI;sNH;HBHH;r
H—HuHV H;rDH謗Ht7HHH=u5H
,uWHqAσti	t>ttZH\$0H
14yHHHyHpH

yHHt[HxHJH
xHHt5HxH$H
xHHtHxH3ϓEuHCt:t5
t0~~&VHd$ E3E333EHHH\$PHt$XH|$`H@A\H\$Ht$WATAUAVAWH@3|$p3у	tMt,t_UH!t$ E3E333>EL%H
|$pL%H
|$pL%wH
p|$puhxHHukHHLcS9YtHIHHH;rIHHH;s9Yt3LaM,$L%H
|$pvLIu3Mu
AMu>̅t3tttL|$8Dt$p1LL|$8HuDdžDt$pu9
qщL$0i;}*HcHHHd‰T$0
@%vI$t3R;u
AA;t
tuL;uD3L\$@I[8Is@IA_A^A]A\_H
H\$Hl$Ht$WH0HH
uHHu(SHd$ E3E333ɉBeHH
DHHtHDHHHu:JSH%RH!|$ E3E333ɉBRIHtHtHH;t	HHׅuRR3H\$@Hl$HHt$PH0_@UVWATAUAVAWHHH3H$H$ EEL3LL$0E!t$(AH|$0D$ 莓Dui)z!t$(!t$ E3EAI_LctbIHHHtJd$(LEAIDd$ %Dt McIʈHHEHu2tHH$H3HA_A^A]A\_^]AD$LILcutHd$ E3E333D?tH3롅u!T$(H=MEALD$ 7qE7&tMHH@΀0H;M|H
H
H8RD؉D$ =uE3D\$ AH8H(H8csmu+xu%@ = t=!t="t=@uo3H(H(H
O3H(H\$WH 39=Vu\H(HHHD؀; w	;t3t);"u	3输tHH< w	HÊuHH\$0H _H\$Hl$Ht$WH0=u:\H[3Hu<=tH&H\uGHcgHHٹHtH
;teH;=ptCHcH,HHtrLHHtHd$ E3E333HL$0HDAHD$ SEL$?HL$0HDAHD$ 0EL$@HL$0HDAHD$ 
EL$AHL$0H DAHD$ EL$BHL$0H(DAHD$ EL$'HL$0H0DAHD$ EL$(HL$0H8DAHD$ H@HD$ EL$HL$0DA^EL$HL$0HHDAHD$ ;HL$0AHPDAHD$ HL$0A	H\D3HD$ XH\$PHl$XHt$`H|$hH@A\HSH HHIHKHKHK HK(~HK0uHmHK@dHKH[HKPRHKXIHK`@HKh7HK8.HKp%HKxHHHHHHHHHHHHHHtHhH\HPHDH8H,H  H(H0H8H@HHHPH [H\$Hl$WH y HH-W{tKhbbHHuMHHtHHtǃ`HHXH;t`HX3H\$0Hl$8H _E3HD8	t<0|<9,0HD8
u<;uLA@AIA:uHtBSH HH	H;
5tHKH;
+tHKH;
!tH [HHXHhHpWATAUAVAWH@3HHHHX9Yu9YuLLH-ĉXXHDgIaHH;uAH(HL艿H|`LH;u
Hlj9^HW`LH;ts~>HL$0AADHl$ HMHL$ HL$0ADAԋL}HL$0ADAL|$ tHAHI[I3<0|<9
,0I8u;<;uLA@AI:uHLHEHHEHHEE&L;tEeHH;tHH;tuHH(LLH(3L\$@I[0Ik8Is@IA_A^A]A\_E3HD8	t<0|<9,0HD8
u<;uLA@AIA:uHSH HHIH;
tEHK H;
t3HK(H;
t!HK0H;
tHK8H;
tHK@H;
tHKHH;
|tH [HHXHhHpHx ATAUAVH@E3HHHL!`D9auD9auE3H-	XH׍O:^HHu
8H]LHu
HKD! D9fhH]LHu
H$Iσ ~8AHEAQHL$0DHD$ HM AHL$ AQHL$0DNjHM(AHL$ AQHL$0DAHL$0HE0AQDHD$ ALu8HL$0AQDLt$ APHE@HL$0AQDHD$ bAQHEHHL$0AQDHD$ @HL$0AHEPD3HD$  HL$0AHEQD3HD$ HL$0ATHERD3HD$ HESHL$0AUD3HD$ HL$0HETAVD3HD$ HL$0AWHEUD3HD$ HL$0ARHEVD3HD$ `HL$0ASHEWD3HD$ @t HHIII<0|<9,0H€:u)<;uLA@AI<uH!HLH(HHMH(HHHMH(HHHMAEMtA$H HtHHtuH(SHGL LH(3H\$`Hl$hHt$pH|$xH@A^A]A\3H(;GH
~H9ts|u3HH(@SH0LHt
HtMu,D|#Hd$ E3E333ɉH0[À9t	HHuHuAAIHtHuHuA#"3H8HoH3HD$ E3LL$LL$LL$LL$LDIBIAA:u$AIEAIBtIcHL$ H3荽H8HHXHhHpHx ATAUAVH 3M;L|?;t=IM>+HcLMK;uKLIM
}}u;~;Hl$HHt$PH|$XËH\$@H A^A]A\@SH IHC$C H [H\$WH0HmH3HD$(HHHtf9taHh&gtQHT&HTuO$DHLD$ PstBH\$ HHL$(H3MH\$PH0_ËO$LD$ A1u3H%HL$ u6E3H%A@f;
tDHA
r3̊LE3'BI<w
B<wAEFLЄuA3ҊHH
ɌH;t2g6Ht(HHtH
H;tG6HtHHH
.6HtDMIH3H\$pHl$xH@A^A]A\_^H8x ~
u~1~
~#Hd$ E3E3338H8É
e̋eH\$Hl$Ht$WH`3IHHL;u3H;u)E3E333Hl$ H;tIwHL$@I舲L\$@AS;uHfAr
fZwf fAr
fZwf HHHt
f;tf;t+VACHL$@LˉD$8t$0AH|$(t$ b;u'@8l$XDHD$P3@8l$XtHL$PL\$`I[IkIs I_@SH03L9H;u&SE3E333H\$ _H;tIwAfAr
fZwf 
fAr
fZwf IHIt
f;tf;t+E3H0[H\$Ht$WH0HHtKBHHHKYHHt-HVLH0tHd$ E3E333KH3H\$@Ht$HH0_H\$WH03H;t
H;vL;u0f95E3E333H|$ ~H\$@H0_LAIfAIf;tHuH;uf9"3H\$Hl$WH0Hd$@H,{HHtud$(Hd$ DL33NHctxHϺvGHD$@HtaLD33ɉ|$(HD$ t:HL$@3;xHHHu3H\$HHl$PH0_HL$@HtHL$@KHHXHhHpHx ATH0HzE3AI;uf=tH@H\CfA;uGHcFHH%zI;tHQzfD9#thH@f;=ptCHcHfFHI;txLHHA;tE3E333Ld$ HHcHCfD9#uHyHWL%yL'3H\$@Hl$HHt$PH|$XH0A\H
kyL%_yH\$Hl$Ht$WH 3HH;u3Lf9tHf9uHf9u+ǃHcHEHH;tLHHHHljHH\$0Hl$8Ht$@H _	f;tHfuf;uH3HHXHhHpWH`HHHHIIIyHL$PHtHd$PHHHY3H\$XHl$`H@_HL$PH\$WH0IHHt23HBHH;s$Hd$ E3E3333]HHHD3HwH
|PLHu-=tHt5uHtHtH\$@H0_H\$Ht$WH03HHHt13HGHI;s#
H!|$ E3E3333=IHtuHHHHsHHtH;sH+H3LHH\$@Ht$HH0_H8u
R
	Rx.;
s&HcH HHHkXHD@"
Hd$ E3E333	\3H8HHHHPL@LH SWH83Hu%	Hd$ E3E333jH|$XطHP0>ķHH0S贷LE3HT$PHH0V虷HP0zT舷HP0vH8_[HHPL@LH H(L@aH(HHPL@LH H(L@aH(HHHHPL@LH H(L@3naH(HHPL@LH H(L@daH(HHHHPL@LH H(L@3:aH(H}T3HH9HH#H
H
UT3HH9
H\$fDL$ UVWH`3IHHH;uL;vH;t)3H;t	Iv$E3E333ɉHl$ 6oH$HL$@L\$@A9k$f;vLH;tH;v
L3H*t@8l$XtHL$PH$H`_^]H;tCH;w<@"E3E333ɉHl$ @8l$XHHL$P7H;t@8l$XHD$PH$$AKHD$8Hl$0L$A3҉|$(Ht$ ȃ;t9$H;thzH;tH;v
L3H_"E3E333ɉHl$ @8l$XgHD$PVH8Hd$ H8HHXHpWHPHHH؃IЉp ,L\$0McHD$0HL$xDHHD$ Dt$x|$HtHD$@H\$`Ht$hHP_H\$Ht$WH0Ht$PHd$ HL$PLcDH%H\$@Dt$PHt$HH0_@SH B@ItHzuA&Bx
HHau	H [̅~LH\$Hl$Ht$WH II@LH@?tH\$0Hl$8Ht$@H _H\$Hl$Ht$WH A@@IIHtIxuA7~3MLHHŃ?uU8*uLHֱ?H\$0Hl$8Ht$@H _H\$UVWATAUAVAWHHPH3H$3HHL$hHHL$xIMD$`DD$TDD$HD$XD$PE3I;uA3E3E333H\$ 8$tH$AC@L
HZHaA;t(t#LcL
IAHMkXMɀ
LL
A@8u)A;ttHcHƒHHkXIB8tA3E3E333H\$ 78$tH$AKE3I;t@/ADT$@DT$DAL$A:H$AHA;H$E<3u2uHA&*A0uAAA׸DA;I]IA0uAAt~A;uEMIDAc;IcH@I;u"HD9uHfDH$@
HL$LAE3A;tKD$DAA;uAEI%AcIcH@I;&Hf$@
D\$LH$@
DMD$@ A@A;I;AcUIcH@HD9Y@D
eg~in#opsVuoxO'AcIcH@I;uHD9jHHAt5I;D$HDNH
A+fD9t	HA;uH+HI;HDMHA+D8tIA;u+sAA$AEAQQD$T0T$PD$UAEy}A	vA;u
I}I%AcIcH@I;HH8TE3A;D$HA tfH$D$DA@A
T$PAsJA;u
MEIAcBIcH@I;ufHD9uAsMA;tAcIcH@I;u"HD9uHL
A A@tSA;uMEIAcIcH@I;uHD9ATHLA;uEEIAc@IcH@I;tHDpA@t6A;u
McEI[AcIcH@I;pHLc4A;u
EEI%AcIcH@I;:HDE3A@t
M;}IAAr
ArEE;}EAD;DO$IH$?H#ʉL$PAE+A;M;t3IIcHLB09~LjI+H$H$?+IA	D$L|E3A;t	;0nI+D\$L0^DźbE;H$@
}AIu@guAEHu-7H
>HHd$ LL$DHT$@AX==qYxu}%}=gXHd$8Hd$0HD$HLD$@A3D$(HD$ lZH
]>Ht0Hd$ LL$DHT$HDXtfD$@	=HL$PH3xHhH\$Ht$WH@H3ۋH;;u+H\$ E3E333Q
HHHH|$0H;t"HHt$Pmf;uιnH\$XHt$`H@_@SH ٹi$ع3fH [fL$SH`f;u
3ff;sHV;fHf#nHL$@I	{L\$@ACLD$pHL$@D$0ACDʉD$(HD$xHD$ 53;u	fL$xfD$x8L$XtHD$PfD$x#H`[fL$SH@f;u3of;sH:H#P=CLu<3LD$PD$03H
@5D$(HD$`DHD$ 4L$PE3H@[k̍A Hl$WHpHcHL$PysbHT$P~LD$PHT$PH@xtHH8|$htHD$`HD$P~6HT$P@.jt@$@$Ƅ$ *@$Ƅ$HL$PD$@L$AAD$8H$D$0HD$(T$ QHL$P2$t
$|$htHL$`H$Hp_H(=mJuAw 3mH(HHXL@HHUVWATAUAVAWH3AAH@ox@$HxEtxAl$pDHL$T9;tE3E333H|$ r@u
|$TtE
AA#Ⱥ;tT+t:;t18^E3E333H|$ D@tuA@D$At,t#tt@uD;AAϋƺL$H#tF=t8=t*=t=t*=t&=t;t/A
AADl$PsA"$AEDDDl$P@@tAADl$PL$Hs
ADl$P@ tA@t
ADl$P1u!8H$DD$HH$H|$0LL$`ADl$(l$ RHD$XHA#;uC@t9DD$HH$H|$0ALL$`Dl$(A׉l$ 1RHD$XHu;HcL-,gHHHkXIDdR[8HR;uMHcL-fHHHkXIDdQȋHL$XQ;u
A;uA@	uAHT$X
HcL-wfHHD
IDHkXDtHcHHHkXIDd8A$HD$LEAtxEă2D$Du88tP}ZHT$@A@|$@	;u|$@uHcT$D:/tE33-2tE<@uD$T#u#=@tJ=t,=@t%=t+=@t$=t=@u($#;uD$@$|$DA@A%=@$=t|=;A;vv8l$AA+ A;PD$DE3sH;tE33bH|HT$DAZaA;t uk|$DuD@D$D$D=uX4=u#E3Az0D$E33X0;;vqA;E3H;E33Hu8D$DAHcEHTDD+famD;AHc@$H@HHkXIDd8@l8HcHƒHHkXILƀd8D8@8|$Lu!@tHcHHHkXIDL A%=AHL$XMD$PDD$HH$H|$0D$(ALL$`D$ AuMHu6qMLcIAHMkXIDBdBHcHʃHHkXILH
H$HĀA_A^A]A\_^]HĉPL@LH VWHXH`E3HAEu(Hd$ E3E333=H$HD@d$0DD$(D$ @DLHT$@HL$DvD$H|$Dt9t(Hc|$@HHHL_aHkXId|$@V|$@tG0HX_^Ht$WHPELd$@3H$Hu(8Hd$ E3E333N3Hu(8Hd$ E3E333$t8Au%8Hd$ E3E333Ѿ`L$0DL$(DT$ DHHL$@'D$D|$@t,t!HcHHL`HkXIdtHt$`HP_LECMK SH@d$(MKIC MKD\$0L$0EˋH@[H8ADL$`ELD$(HL$ DAIWH8HHXHhHpWHPHHHHIIm3H;u@8l$HtHD$@3HL$89iuLHHJ[H;u<E3E333Hl$ ]@8l$HtHD$@-H;tAHHDL
tUH;ufDLZ@8/uCfHff;Qrf;QwfQ$f;Qrf;QwfQDtDHIELtNH;u^H@8.ufQfAHfDfAfD;Arf;AwfA+f;Ar%f;AwfAADt
fAf;uf;H;u@8l$HtHL$@H\$`Hl$hHt$pHP_E3H\$Hl$Ht$WHP3IHHL;u3&HL$0IkL\$8A9kuLHHH;u<0E3E333Hl$ z@8l$HtHD$@H;tAHHFDt-H;uFDu[fG@8/uf
ffHHFDt#H;uH@8.uf
ffHf;u&f;tH;u@8l$HHD$@@8l$HtHL$@H\$`Hl$hHt$pHP_E3HT$L$SUVWATAUAVAWHXAHcADd$4\$8A;u38	3;;[HLL
IKHkXD1v8~;H;tD|18AEAAσtuШtLdШtA;AB؋LH;u=$3DBL
ELKL\0@KIA
D0HL0	A:;AMKAAIUAhDD0	D:tbKL09A:tQ;tM
KAHAhDD09Au.KL0:A:t;t
KHAhADD0:KLL$0DH1H|$ D;HcT$0;H;L7KD0yA;tA}
uL0d0HcIMIHD$@L;:
A$<
@:t
HIHD$@HL;sID$8
u	ILKLL$0H$H1AIH|$ C;u
C;u{9|$0tuLTKD0Ht"$
t'@+K$D1	GI;u$
u
3$AHY$
LtL@+HL;d$@KD0@uL0	A$HËA+A;AI+uIAI;rI+AB8VtBV;u*A;uHcH^KD0Ht;I߃L0	|KI߈D19uKI߈D1:HcH+$EHc.D$8L$A+DMʼnD$(3ҹL|$ A;u
BbADd$4;HwJ@|0H;׺
tfA9UuL0d0HcIMN<(M;{
A$fEf;tfHI%IGL;sID$f9u	ILKLL$0H$H1AIH|$ @;u!A;9|$0LKD0HtF
f9$tKf+$KD1	$KD19KT0:WI;u
f9$uf>$HDBk
Lf9$t
Lf+HM;"KD0@uL0A$fHA+Dd$4L$M;tI`gADDAi?u	 muD뮋$3)8	E3E333H|$ HXA_A^A]A\_^][H\$Ht$L$WATAUAVAWH0ALHcu3ۉi	3;;=#TLLIL= TAMkXKBL u.8	H\$ E3E333[A;u+H\$ E3E333nKBD tDIՋs	s)c	H\$ E3E333譱H\$hHt$pH0A_A^A]A\_H8Hu&Hd$ E3E333gHLH
G33<H8̹邧H"t


ahHt
Rk"t_H$>HL$03A
VH$3HD$@HD$0D$0@HD$ H$HD$(I>HL$ 6>Ī̋:"D#AD#DD%"IDL$(EЋLAH%;H\$Ht$WH@HHL$ IA`DL$pLË׋;|$8tHL$0H\$PHt$XH@_@UATAUAVAWHPHl$@H]@HuHH}PHH3HED83MEDHDfD;u7E3E33;;t582<D8xEDD8E;D;D;u'uh;uHpE3E3AA:LcD;u3~g3HBIHrXKL$Hw1HAH;w
HH5)H+H|$@H;tGcHH;tHHH;tELAA%:;t8E`A3H\$8LNjH\$0;u\$(H\$ 	D$(L|$ ;<HO9u@HL$@LΉD$8\$0AH|$(\$ u脨y|$XtHL$PH\$pHt$xH`_H(=qufE3H(H\$Ht$H|$ ATAUAVH0MMHL>VHx0H|$X3Hu%Hd$ E3E33319HWHMMHHA֋H׋HqWH\$PHt$`H|$hH0A^A]A\MLHH
3MLHH
$MLHH
LHH
E3LHH
ߢE3LHH
OE3HHHd$0d$(AH
E3ɺDD$ "HHHHHHd$0d$(AH
pE3ɺ@DD$ U"HHHH(H
}HtHtK"H
\HtHt2"H(H(AAMD}3LL$PDIA)!H(H\$Ht$WH@HHL$ AIE}3LL$pDH׋ |$8tHL$0H\$PHt$XH@_HHXHhHpHx ATAUAWH H33DG9LHtPDG3ҋ#Ht=HH+H;!AWHM!HH;u1H\$@Hl$HHt$PH|$XH A_A]A\úDDI;HEMNjK,tHH+H;~դ8u諤
HAԋ LH3 U}]E3HՋ>HT5HHHHHu%B
WH HE3IՋH3Ht$H|$ L$ATAUAVH0HHcu F	;54LLIL54AMkXKBL u0谣 舣	8Hd$ E3E333В3Hu-t L8Hd$ E3E333蔒d}KBD tH׋r	8+ 	8Hd$ E3E333.Ht$XH|$hH0A^A]A\H(HcH(H\$Ht$WH HcANHuo	RDE3Hu*3t	wHHH3HHHkXdH\$0Ht$8H _H\$Ht$L$WATAUAVAWH0EDHcكu38ɡ	3;;2HLIL=2HkXKL0u+蚡8s	H|$ E3E333轐mKD0tEAՋ+	@8)+8	H|$ E3E333NH\$hHt$pH0A_A^A]A\_H\$LcH1MAIMkXJBD8F\ADA@tXtHt(t uHBLJBd8BL80BLJBd8BL8BdBLJBd8EuA%@H\$H8@t7t/t'۟Hd$ E3E333$
#3H8H8Hu'螟Hd$ E3E333
3H8H\$Ht$ L$WATAUH0Hc@tHt@t8t0t(#Hd$ E3E333lu	;=/HLIL-/HkXKDLu%訞	Hd$ E3E333]KDDt
Ӌb	R#I	Hd$ E3E333蒍H\$`Ht$hH0A]A\_%l%n%p%r%t%v%x%z%|%~%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%V%@%2%$%%p%b%T%F%8%*%%%%%%%%%%%%%t%f%X%J%<%.% %%%@SH0Mыمt*;tA;u!HD$xDL$pLD$hHT$`IHD$ H0[H\$WH H3HHWLHt4HȊt&<"uH	AIHÊutAH>3H\$0H _HHXHxL` AUAVAWH0LHE3L!xAOu3|L;3HL$`WtuL!|$ E3E333uHL$`Ht3uH\$`5Ht3Ht"3H
HH
HEMtI^LHSBL8DQHHLIHvtHd$ E3E333KHLl\A8Uu:H'L;t_LWIHvtIHd$ E3E3332A}/t+L#IHhvtHd$ E3E333LJMt'MIHH0Hй@H0]@UH0HMPhH0]@UH0HM`QH0]@UH0HHMH@H0]@UH0H4H0]@UH HH ]@UH@H}Dt7}Ht'HcU@HHHL HkXIdU@H@]@UH@H}@t>}Dt*HHc
HHLt HkXIdH
hH@]@UH0HM`QH0]@UH0HHMX?H0]@UH0HMP"H0]@UH0HM`H0]@UH0HMPH0]@UH0HH0]@UH HHcM HH!H>H ]@UH HH ]f///v//T/B/2/.)).....z.h..F+T+d+t+++++++++,&,:,L,b,v,,,558+h5\5L565&5554444444j4Z4@4&4433333&+++****z5****r*d*N*>*(***x3f3V3>3503/00$0<0V0t0000000011101B1V1r11111112"2,282J2Z2j2v22222222223/,,-P.B.,. ...----,---n-b-N-:-*-"---,///ؤ@ @@0@(P@]@@
IZCreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\Please wait while running postinstall script...-installIsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removedYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %s%d Root Key: %sAre you sure you want to remove
this package from your computer?Please confirmOut of memorycould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptnamemetadatatarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfainvalid distance too far backinvalid distance codeinvalid literal/length code`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

incorrect length checkincorrect data checktoo many length or distance symbolsinvalid distances setinvalid literal/lengths setinvalid bit length repeatinvalid code lengths setheader crc mismatchinvalid block typeinvalid stored block lengthsincorrect header checkinvalid window sizeunknown header flags setunknown compression method inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScs	
!1Aa 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionaryе@@8x@@@@x@h@P@8x@fFK
I*TK
ITTK
IO :i+00SBi+00@_dP/N  !:i+00'":i+00
E%6NKKº}`fUܭHb0RF#/xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF΋!	Hx5i+.b`ODV	AH
FM^2mFT
d_N"
(2W]/4*&{-zeG'{-ph}OUBlOU3(9O> G e+.bchOU4^;ݧB}/NKfNr@"=3H$Oڠ'my4[J1B&M[OrG:ᠷqEJ ǬMWs5i+.bs5i+.bs5i+.bw~s5i+.b%e{HqC,㐲RO$[Dt.|I)sO>+dWnO@;>V;>V
Wt חb@J7<}iFϦODa'wj5Ob0wDObAGQ`{FL!mv`[c'wj5Obd'wj5Ob6J[CAVgqe'wj5Ob5i!Lz)zR88`[|^1/`[@L\J7@呰 חbu`ެ@`ެ.PRO—-T'tE`ެA`tpZdl?<W4plTI?rPB,ɨ=O${aPo0p,oiyŜ?Oɝa4Oص,OꙠς`RWpO6OyѦjc(=O0%G`묡51Mlg~6JNfs3K@~Oq!2)wKL+2V4K@~OqT'B6Q:.7V`ƆEz5K@~OqiI~+.ͩpO]_eOkm'WFAOлP0P0P0M]`gI6FOEг]K$^5N$̈&HS3M17i;'$9Y:Oh7%9Y:Oh7&9Y:Oh7'9Y:Oh7ի|I˃(9Y:Oh7!FsGF{H@FS2IEt$#CȫR
e.{ JOe/P($IZ^9$\E9O奄`OO\;x8WFTpj@wiKw^ևA)!\_[C+dWnO4DLe+.bSmb`ߌ #Or'>O.jxO^QmOd4'>Or3߷;`[MOKLb`wG:J'i>VMYFDAt;&OF}Ҩ\I;%S|
*E
yЎf|txMNI{@>KJ\FЗ4mc-NvEc7VfCNItwׄ8A!ӱJ'8EK}4@VqC(DW@XzvF@S>LNdL֬+o.Eцݷ"JL
:̿,LB)隇A }jL^6CTw]+.DJQS[bHNAFPCU	.4zl'K@-tК#FlHiawhM0Y3S!AbostA^?UX2NfHyu	5ꥂG)]/qNnN9jI=W.I|Kg
4cH~%]bM
I]7BWGCQl2$HܨEye64ۅ>eL:er='oOU{p OsCů$53QB`ϝ]v+qAO;ل.CZ0YcwN]ND.Q1RWHΨ}'CBg(#l^"`G3qs03NvFZ9\;û@Z|KJ$M>MEQ wmjKDWw? ec
E
kjO}c^NIe2mG)fpNr-O&oO}N8úGˢ)qKmHB" C[E|ti!OL'`gp+J=$?xԒhKGM]k>+$%|QOz)(BqF[͟WÅm]rLwx,4Ku@+׉#G``WG 35A	AlG؂تI`FtQ<[MEĀd_NM&uf4L3lEZIC~"@0(9A8L"k1%B	T
#F@FDF[Fʙ^AiXשFh
Mm8gh
z0Gd<O8mxO4yO"FFFMm8gh
0F1F2F3F%F)F*F0:s*Dw=IFy.Y+F&FEFGFHF:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/Oǝv\Wސy(_FFFFFFU
8r+C+n44FâRX0eu{ڮP9Vu{0ne0E
Kvne
yOܦϫ|xOjIOQnO09$-1.E^*onePone |~|?ne?PE^#1$-?W2$-?W2$-pw~?neg@ne˳j@ne˳j@ne?W2$-~{S^BEy|KDphKΔӳOհrIOxhO{lhO\`OOrOh7y)
Oh7BTyI6E9A!8ҏFs%E~2]rgO!B>9}Nr*GݓkFN]ͷghhϓgAc*^Z%Ȕ2AeqKW';?B@
J$SQ`Ɔ(œO>1s-O(hHjxOiQD(ߥl+ rˆLmCBUa{Ӱ~C.`1y/DĊYF;3bpc(Jg
Дէ{E]E)ПS-oEH?syYz(XGA'qQUAJ
sY!WOZ{*lg(M2(TfC'>|a. 	O;O.K[K8H]҇26 -&{-r:
%wCjW'tVamy!@iaWBVm`ɠI-`:Bn5OCښL%2J4{[kYs=BMQ!B\[/B{NsASÖ.̆I#t9JDf?kјH"tŻ-Gs?zZAe!`[ǽ6NXX$KiiőԞ(LqmjKH(.~,-Y@o3\.QCpg{L\l%IT߁KIs<_z\
LKo(t;sM|@)^vJYӞ~+IzÊChsxDpWJ?,CP0DOAoZ\q"tDk׾TLrTIkE
a`NNe76_I|kHrYM>s:
.jxOˡd:aDX7iii9P5}+EutX(T6QB~ۜC]_#ͼ_Ld=xr|խhG2`?uIp4Bf6חKt3
SNwL1"(iv@	YGح+ObC4`[ԄLr?RJ{,AsEOWL"O7v8yOhKKt&1Zs~:6B}Ftr⋪GMv2̤pDʹfD.b[GvtH;
zr\GڙYkH?x9J4uY&HxHϣ'GVBeUNOyדسDg,ݠeL3"5/QqCAwSk5X;-3B{_41lxƱLb
VBPoz5zD #D@Fgm[M/BT|\?@zpDF[0	49Z
I}AaB}KX䌠%D|DZ#&oIQd5CvSdn0@DH&'E4VwҁnB*O&-bfMlV!jt€I$[a#FVODJ

hFXapf_:qJ?򥸱PpZdFK6eJ7`, :i+00Fh3MnMܙS{5)xKt	O3CKsw`$D&l;0MHֿRUBu(dT&arrCuƋ.|uU:WPHw[ێ	Z܊M`* !sG3^F0MJSkyZ
8y
M3,/KqI\M;TQI![Y
,!PCsg?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;runtime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODESystemFunction036ADVAPI32.DLL         (((((                  H          h((((                  H                                 H	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~united-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamerican@ENU@ENU@ENUx@ENAp@NLB`@ENC\@ZHHX@ZHIP@CHS8@ZHH @CHS@ZHI@CHT@NLB@ENU@ENA@ENL@ENC@ENBp@ENI`@ENJP@ENZ8@ENS@ENT@ENG@ENU@ENU@FRB@FRC@FRL@FRS@DEAx@DEC`@DELP@DES@@ENI0@ITS @NOR@NOR@NON@PTB@ESS@ESB@ESL@ESOp@ESCP@ESD@@ESF(@ESE@ESG@ESH@ESM@ESN@ESI@ESA@ESZ@ESRp@ESU`@ESYH@ESV8@SVF,@DES(@ENG$@ENU @ENU@USA@GBR@CHN@CZE@GBR@GBR@NLD@HKG@NZL@NZL@CHN@CHN@PRI@SVKx@ZAFh@KORX@ZAFH@KOR0@TTO(@GBR @GBR@USA$@USA6-0OCPACPNorwegian-NynorskGetProcessWindowStationGetUserObjectInformationAGetLastActivePopupGetActiveWindowMessageBoxAUSER32.DLLEEE00P('8PW700PP (`h`hhhxppwppCONIN$CONOUT$TMPRSDSXJ\I ORo:\src\python-3-trunk\lib\distutils\command\wininst-9.0-amd64.pdbdT42p
dT4pT4p)4=4
p`PT42p20

4
2pd
T	4Rp
4,
*p@	X0
4Y
Vp
42
p`P9
%+t$d4#
PxdT4ptd
T	42+T$4#p`
4
pP*p` d
T4
rp

4
Rp$	,	p`P0Pp`P00	td4

4

rp!00'	T342,p`P

4	
Rp204"t1"d0"T/"*@(	dX4WR
p+@$d241.p`B	b0dT
4RpdT
4Rp2020d4
rp7
%d%T%4%pP'	T9482p`td
T	42BB&p`P00		"0/	dT4
p0bt4t
d4tdT4Bd'4&$pB	b
	p`P0

4
2pdT42p	
p`P020dT42pd42p
d
T	42p)4
p`P20B		R04rpd42p2020tdT4bbbb

2020d42p4R
p`P2P200̝؝`RPd	4Rp0<R`rP	
	p`00mf`RPbp`00D`BBBBB20B2020BBp0		b

4
pbdT4pbbbb

4
RpRP4	Rp0`dT4RpRPt
d	4R0Ю`B
tdT
4
dT4p
4
p`P

t4t
dT4
R-
Etd4C
P`
T4p`bbbRPt
d4r0Acah|aR00Bb		bbbb		bBBBBr0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r0r020r020!!

d	4T2p!p!  Ԃtd4pPd42pRPrp`00,a

4
2p20202042p

4
2pbb

4
2p2P
d4rp0Ga20202P	d4p0>J+iaB		0

4
2pbd
T	4Rpbb202020rP
p`001aT4Rp`
dT4p2PB0(a2PB0GMa2P200pzat
d	4Rd42pbbb
td
T	4RBB2020R020R0d	4Rp20d42pdT42p$d4pp2P

4
2p0Rar04r
p`P82P
t
d	4R0bBd42p

20202P200bR02P2P2
0014bLsTb2P2P

4
2p0			mb	&	bbp`P0
td
T	4Rd	4Rp
4R
p`P&

	p`P0)4MB
p`P$		p`P0
t	dT42RPRPRP
t
dr0bc#b=bB2P2P

4
2p0"-cBi c

4
2p202P2P42p09c	@Yc2020dTpBBBt
4RB

4
2p20dT42pd42p
4rp`Pd42pd42p
4Rp`
PR020dT42p
t	dT42
t	dT42
d
T	42pd
4p  d T 4 rptd42dT42pB2Ptd420c44rc

4
2pdT42pT42pb2P
	td42077W7c2P2P
t
4r0Y88c89cBpPtd
4R0j::c
T4
p`	 
  t d 4 0==T@

4
2pt42		2020dT42pdT42p)4dZ
p`PbRP
t
d4
R0NO)dbbbbbb2Pd	4R0PKQAdd42p202P2P
td
R0RRZdVRRd2P42p0DSNSdd	T42pd42p20BBd42p)4ZP
p`Ppd42p20BBd42p+4ZP
p	`Pp

4
2pRPd
4Rp0o}}d20/4qf
p`P RP
d4
Rp0(Ydr0r020202020d
4pb
T4Rp`2Pd	4Rp0d0dT4pbbR0b
td
T	4Rbbbd	4Rp
d
T	42p202P
t
d	420"eB

4
2p

4
2p

4
2p2P	B0W e	B0B	B0BdT42pB2Pd42p0МAeBBRPtd4
r0ǞҟWeRP
d4r
p0Kmed
T	4Rp%	
p`P2P	b0ǥeǥBB

4
2pd
T	4Rptd
T	42d4
Rp
t
dT4
r

4
2pR0d42pd
T	4Rpd
T	4RpRPR00eRPt
d	4R0H,eRPt
d	4R0yae1
dT4pBBBBB-
Etd4C
PXd4p1
5#td43r
P8d4pB
t
dT4
r2
0T42p

20dT4rp2
0tdT
4rBR0b td
T	4220
4

Rp($d4p!4p`P$T4p
4
p202020
td
T	4Rb 
T4rp`bdT4pR0d	4Rp

4
RpT
4	Rp
td
T	4RdT42pdT4pd	4RpT4rp

4
Rpd	4RpbRPbp00CeBBBBB4p
`Pbd
4pd	4Rp20dT42pdT42p)4dZ
p`P

t420dT42pdT42p)4
p`PHRP4R
p
`0#f

4
2pRP
d4
Rp02f20

4
RpRP4Rp0IfdT
4pPRPd4rp00af2P200`kzf

0

r0

T
pB!
!4!p`PrPp`0%&frP

d
p0+'O'fr0bdT
4pdT
4p	
p`P
0RP
d4
Rp0342gbd4
rp-
Etd4C
P@d
4pd4
rp

4

rptdT4bbbb20b('EC
	p`0PpdT
4pbd	4Rpbbbd	4Rpbb
td
T	4RdT
4p$
53
	p`0PXd4pd4pBRP
t
d4
R0NNIgBBd4
rptd
T	42RPt
dR0pSSagBd42pRP
d4
Rp0HUyUxg4bbRPd
4Rp0X;XgR0

4
2pRP

t4
R0\]g2P2Pt	dR0 ^J^g]]^gd
4pR0B$)Pp%,p(\.pt$.hp`$/p(/`t)/Huf///v//T/B/2/.)).....z.h..F+T+d+t+++++++++,&,:,L,b,v,,,558+h5\5L565&5554444444j4Z4@4&4433333&+++****z5****r*d*N*>*(***x3f3V3>3503/00$0<0V0t0000000011101B1V1r11111112"2,282J2Z2j2v22222222223/,,-P.B.,. ...----,---n-b-N-:-*-"---,///PropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrornCreateDirectoryAGetFileAttributesA	MapViewOfFile{CreateFileMappingADCloseHandleSetFileTimeDosDateTimeToFileTimeGetLastErrorzCreateFileAOUnmapViewOfFilelstrlenAMultiByteToWideChar"GetProcAddressLoadLibraryADeleteFileAhReadFileSetFilePointerGetFileSizeNFreeLibrary
SetStdHandle>GetStdHandleLocalFreeIFormatMessageA\GetTempFileNameA^GetTempPathAGetModuleHandleAzGetVersionExAResumeThreadSetPriorityClassGetCurrentProcessGetCurrentThreadSetThreadPriorityCreateProcessAGetModuleFileNameA}RemoveDirectoryAGetPrivateProfileIntAGetPrivateProfileStringAGetModuleFileNameWKERNEL32.dllMessageBoxA&GetFocuswsprintfA|SetDlgItemTextAbSendMessageAPReleaseDCGetDCPeekMessageADispatchMessageATranslateMessageEndPaintqGetSystemMetricsBeginPaintDefWindowProcAUpdateWindowShowWindowgCreateWindowExA7RegisterClassALoadCursorA	MoveWindowGetWindowRect"PostMessageAWGetParent]SendDlgItemMessageA!GetDlgItemvSetCursorUSER32.dll4CreateDIBitmapDeleteObjectSetTextColorTextOutAfSetBkMode^SelectObject:CreateFontARCreateSolidBrushGDI32.dllfRegQueryValueAHRegEnumKeyExA*RegCloseKeygRegQueryValueExAZRegOpenKeyExAwRegSetValueExA2RegCreateKeyExA7RegDeleteKeyAARegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dlloCoUninitializeCoCreateInstanceACoInitializeole32.dllSGetSystemTimeAsFileTimeHeapFreeHeapAllocFileTimeToSystemTimeFileTimeToLocalFileTimeGetFileInformationByHandle=PeekNamedPipeGetFileTypeEnterCriticalSectionLeaveCriticalSectionGetDateFormatAlGetTimeFormatAHeapReAllocGetModuleHandleW/SleepExitProcessqGetCommandLineA<GetStartupInfoA;TerminateProcessLUnhandledExceptionFilter#SetUnhandledExceptionFilterIsDebuggerPresentRtlVirtualUnwindRtlLookupFunctionEntryRtlCaptureContextWideCharToMultiByteoGetTimeZoneInformation]GetCPInfoTGetACPGetOEMCPIsValidCodePageEncodePointerDecodePointer@TlsAlloc@FlsGetValueAFlsSetValue?FlsFreeGetCurrentThreadId>FlsAllocHeapSetInformationHeapCreateHeapDestroyWriteFileSetEnvironmentVariableASetEnvironmentVariableWRtlUnwindExDeleteCriticalSection
FatalAppExitASetHandleCountGetConsoleCPGetConsoleModeSetConsoleCtrlHandlerInitializeCriticalSectionAndSpinCountLFreeEnvironmentStringsAGetEnvironmentStringsMFreeEnvironmentStringsWGetEnvironmentStringsWSQueryPerformanceCounterjGetTickCountGetCurrentProcessIdLCMapStringALCMapStringW@GetStringTypeACGetStringTypeWrGetUserDefaultLCIDGetLocaleInfoAEnumSystemLocalesAIsValidLocaleCFlushFileBuffersWriteConsoleAGetConsoleOutputCPWriteConsoleWHeapSizeGetLocaleInfoWVCompareStringWSCompareStringASetEndOfFile&GetProcessHeapSoftware\Microsoft\Windows\CurrentVersion\Uninstall@x@8x@0x@8x@(x@8x@ x@x@x@8x@@x@w@0x@w@(x@8x@ x@x@x@8x@w@w@w@w@w@hw@Xw@@w@0w@ w@w@@v@`@v@@v@N@v@N@v@X@Software\Microsoft\Windows\CurrentVersion\Uninstall2-+] f@@x@t@p@l@h@d@`@X@P@H@8@(@@@@@@@@@@@@@@@@@@@@@@@@@x@h@`@\@P@8@(@	pF@ @pPSTPDT H@`H@
		


!
5A
CPR
S
WYl
m pr	

	
)

                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ                          abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ J@`y!@~ڣ @ڣ AϢ[@~QQ^ _j21~@C`O@`O@`O@`O@`O@ V@@@@pF@pO@pO@ J@@@	@
@@@`@0@@@@`@8@@@ x@!@"@x@y@z@@@
@@4@4@4@4@4@4@4@4@4@4@
;Zx0Nm:Yw/Ml@@.V@n@n@n@n@n@n@n@n@n@ V@.,v<1`4jpx]`XX  `#`#%$ %&@&(\(((**c+d+++q-t---'/(/00;1,<1M28P2Y4L\44l45xD599==Z>\>@@@@AAAABBFD(HDUE<XEiFPlFFdFFlFGtGILLLMMNNNN6O8ORR?T@TBW DWOX@PX'[H([[P[^X^mbhbb|bcccc
hhiijjtc4TXՏ`h'p(q|tѕԕ}LLnpə̙	\\n<pl%(EHehФؤCDqtʦ̦0ͧ<lD 6P8۪XܪlEtH}|=@RT'(bl4L@dvpx*,FHfh(08@
H2P4UXX|`|hpx
14 ghKL24~klWX C(D0&8<@HQPT|Xlpln`pbbqtGH(9<i(l08@ELHX`h|L,	f	p		(	}0	D	L	T	\	d	t	X	X	7	8\	\$
XD
XX
h
#p
$cx
d,



V
X

$
$

e
.
00`T`\(x(  HXGH >	`L			


(
;H
Dax

~
( (]8`l1t4=|@ll 4 w    !!!!("("''C(D(( (t,0t,,H,-P --X-.l... //0022"3$33333445D55P5h6dh66t67799::=<=y@T|@@@AAAA;B >=> @>> >> >]A AB BC CD DCD!DDfD!hD{D!|DE !EE0!EE8!EF@!FGX!GLl!L)M!,MAN!DNeN!hNO!OO!O'P!(PcP!dPP"PP"PR"RS@"SSl"STt"TU"UV"VV"V'W"(W}X"TZZ#Z[#[]$#]z^d#|^i_#t_`#``#0`~`(````4``d`````aa,a,aGaGaiatiaaaal	aa	aa	aa
ab(bbb4b4bMbTbmbmbbXbbPbbp
bbh
bc`
cc
 c9c
9cRc0Ycrc(rcccc|ccccc)d)dAdAdZdtZddddddddddpdeee eAeHAeWeWememeePeeeeeeeeefdf2f2fIfIfaf,afzf|zfffff2g<2gIgIgag!agxg8"xgg"gg"gg#gg\#ghT#(@pnklmn	(	8	H	X	hx
 $ZZ(n,	BBB999111)))cR[RABZRYRZRAB[R[RAB[RAAB[ && &&&@JQ1AA1ZQ1111ZQ1AAZ@JQ1AAZQ1AAJ eu eu @ABZ@J@G@F@F@G@AABX@J@AABX@J@J@AA1X@J@G@HRX@G@AAG@ZRX@AAG@JQJed%ed%ed@AA1ZQ1AA1X@J@HQ1AA1X@1A1ZQ1AA1ZQ1A1J  & & RAABZRABZR[R[RABZRYRBZRABZRBW@J@J &R[R[R[R[R[RABZR[R[R[ & & & & & & &@J@J@J@J@HQ1AA1X@J@J@J@J@J@J@G@J@G@JQJ@ABZQ11Z@J@AAG@J@G@GQ1J@AA1ZQ1YQ1[@J@AAG@J@G@1W@J&@I@G@J@J@J@J@G@J@G@Z@J@AA1X@J@HRABX@J@HQ1AA1X@J@J  &  %& & & &RAABZR[RZRAAABZR[R[RABZR[R[@H{SetupMS Sans SerifP}
This Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.P}PhnP}@H{SetupMS Sans SerifP}
Select python installation to use:PP}7Python Directory:P}jPhnPP}BInstallation Directory:@B2Find other ...@H{SetupMS Sans SerifP}
Click Next to begin the installation. If you want to review or change any of your installation settings, click Back. Click Cancel to exit the Wizard.P}msctls_progress32Progress1P}Installation progress:PhnPA@H{SetupMS Sans SerifP}
Click the Finish button to exit the Setup wizard.PhnP}(
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/command/wininst-9.0.exe0000644000175100001730000057700014467657412024207 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$6Bry,ry,ry,6uy,l+Ty,l+dy,UAqy,UW}y,ry-y,l+y,l+sy,l+sy,Richry,PELI	6P@`@R@P.text56 `.rdata*P:@@.dataJ@.rsrc@@@tt/u\@uVt$Ul$W|$S>toj\VUbYYt_WTQB؃u'jWXQButWhSBjՃWjYYuh\QBt
WhSBjՃ\Fu[_]3@^USVW=8QB39uuEVhuVVSu׉EPK:S.MK SFC*NȋEύDEEU+AuEP@u+MI<\Mt}OGGuSBfu}EP,QBeDEE5PU@u+EPuQEEMȃ8uFPuEPbE}EP@uM+€<\tGuCPCPsEuPjt"uNssQuP9}tE@PE@
PujUE@
E9EV6M4ȋx@uN+NjAu+΍}OOGuʃMȉMMI+ȍEp@u}+ƀ<\t(uVFu+<7/t}OGGuSBfu<\tPuQBEV8V\]Y
hXBsYuHQBuQBEMp_^3[qVtUB3ʼnE3V9Et=PPQVuPhhPBVPidPBP,QB+WVPhjh,YBP5%CdRBM33^UUB3ʼnEVWEPuhP
kEHHHHtnHtWHtH()CuhpYBxE5RB}Pjh5(CuWh5(CjPYBY3tu%uY()Ctuh{V4tRYBY;N;t
+V+щ`C+FM+F+~h[YEEPhpPBttuEjhYBPlPBt\3PPPvPujEtQvWPfEp@u+ƍD8PRYMuE4QB3@9ut99ut49ut/;t+39uh%CUuuJU^[UQEPhpUBuDCuujh$UB(CUQEPhpUBuDCuujh$UB(CøMB3ĉ$$NU$V$-tW-t/HP$hhUDRBVhURBVjhhUDRB3@I0)CtPjhrhUDRBhCD$hcBP0RB5RBD$PhUhlcBhUv1t(8jjhpUHRBPLRB5HRBSW3WWhpU-(C%CPLRBWWhkUPRB (CÍp@u+ƀ(C\tOGGuSBfÍp@u+U(CSYY$5'C5%C/5RB\Ct8thLcBSU5\CY=%Ch8cBSUh"@5$C5(Ch (CWuhcB/Y=%C=Ct:hbBSUhbBh5(Cֹ@C33XuBFMuҋ#Ƌ#_^[3t3uSVW|$j +[7T$Ku_^[U}uE33AE @L@ |EVPPEuYYEPzEYt΍Q}t'PEPEYt΍U*}u3E^ËT$u3t$D$YU@EHPSKLMԋ+MVpWxOωMč:MЋN(M܋N,MN0MN4M؋N8MN)MMMAGMu+MM#+MM;Ms)MMAGMu֋MUvLBj3YM@mAGAGAGHuE +ʃmAGAGAG}w}tAG}vIG;]s7;}#,@B@tB t
@XBM+)M3AыMJʋU#эKOHM+˃HM+ρHE_V8F<^[ËL$3;tMA;tFPQQQA00PP@P P(P,P0P8PuBJe^8~u63WWWFjEPEEvF3F ftH0Fj3Yuk$<tE@BS˃;N$vE@B133@WWWFMӃ	FA03E@|Bs'}5EMEr܋U^tBBtB`BF t
Ft ]jEP]vUF33 s'}EME r܋UF tXFt0EE]jEP]vUF33s'}$EMEr܋UF tˁHN AFt ]jEP]vUF33Fths'}
EMEr܋UF ^@tXFt ]jEP]v"UF33F t`FV@EU;vE}tdN t4AE؅t*AI+‹U;v+MQMuQFtuuvFE)EE)F@~@Uf@Ft~}3ɋEAMN EtQU؅tV@;Q s	M؈F@tM;MrFtuuvFEM)MMUF t`f@Ft~}3ɋEAMN EtQ$U؅tV@;Q(s	M؈F@tM;MrFtuuv`FEM)MMyUF t`$FtDs'}KEMEr܋UF;tBLB
33F tV3A	#щP,F H03PPPMFA0 s'}
EME r܋U˸#ȋϋ#ύFB033
~:
3PPPMFA0}R
U~tσ+	s'}&
EMEr܋UÃFÃOt/HtHtHu,B8B
OOg	σ+ s'}	EME r܋Uˋ%;tBB	3ۉF@3F@EYE9EvEE9EvE}'	uuuE)EE)EE)F@s'}EMEr܋UÃF`Ã@FdÃ~`F\w~dwfhNBB+}uEMEr܋NhM0BÃfDNpFhFh;F\rFhE0B3fLFpFh~hr卆0NlFLRFTPQjFpPjE܅tE@؎B~fh}EMENT3@NLH#ËɉE;wfsK"}eMME;r̋Fh+fMfLFpFhef}uV}MMEH;rڋ+Fh3DFnEÃOOf}uZ}EMEB;rڋjÃ7}EMEB;rڋjÃeY+NdVhN`;vpE@B>0NlFLRFTPQv`	FpPj
E܅tCE@BNhfUHfTNpFhuFdF`9Fh닋E@BUNlFPRFXPQvdF`DFpPj<
E܅tE@B}rY}rPEMuHMHMMHP^8~<
E^8~}'EM;AtE}t
j7}E+G]+_G_^~Et,t(GS+Ã~PvtAFG0Eԃ>u3ɋV҃@V
tjX_^[Ã>
uPPPZt$$SPO;Ftj׋Get
jF(|$;v+PSv4	F(F,N4W+SQ	~,F3끋D$t@t@tL$H a03jXË39D$vASWs8T$ځ;uAt3jZ+ы@;D$r_[US]VW{{u
<sjjX9tAG<ȃg8+3ɉG<rG8o8GCYYEtjsSoECsY3jX_^[]ËD$t@t8
u
x<u3@3jXUQQSVW39}u;^;F ;9~$h0%jv(ЃE;uj}9{4t(K$3@jPv(V E;u
uv(V$YYɋ}jYh0%uSVCL00;r/,%;w%++0FLCP++0FPCl}++0FltK$3@Ps4WE~4p3jX_^[Ul$B3ʼnE\ElUxEE|SE3VutWjY}<33ɉU9}pvEHDE3B}h]E܍J]UUMur3@MM*MMM;M}
EfU&~M	UɊUUfE`3fM3ҋ+MBMMMM])U+˃}]u3ҍHBMut	Z#3ۃELE<f	]fu;EEMAE܋U;&M#ˉM;M}uUM<ȋE3+B;Es(EDE<E+Ӆ~AE@@EE;Er3@UU9Ehu
}Eԋ]ЉEML+fLEz*ME@M3fMJ}tM#;MtEe>EMM3ҍHButJ#ʋ3ۅuEMEЉ3M\_^3[C`øSBjUXËD$B+ȋËD$D$P&Yt$Y%,PB%(PB%\QB%XQB%TQB%PQB%LQB%HQB%DQB%@QB%~u蓌YjhB<{3u3];;u CVVVVV639u;tԉ]S)YuC@uwSYYttȃ@)CBA$u)tt@)CB@$tBVVVVV
6M9uu#S蕓EPVuS5ESWE	E|zuYËUEPuuuס]ËUEPuuuۡ]ËUEPjuu]ËUEPuuuġ]ËUEPjuu詡]øBá:CVj^u;}ƣ:CjP*YY*CujV5:CYY*CujX^3ҹB*C B|j^3ҹBW@)Ct;tu1 BB|_3^=CtW5*C=YËUVuB;r"Bw+QMhNY
 VQB^]ËUE}P hEHY]ËE PQB]ËUEB;r=Bw`+PfY]Ã PQB]ËUME}`QfY]Ã PQB]QL$+ȃYQL$+ȃYU S39]u?SSSSS"3MVu;t!;uj?SSSSS2RE;wMWEPSuEPEBuu
;tMxEEPSYY_^[ËUEPuuuuh]̋L$WVSًt$|$u't+t/uuatt7uD$[^_tuutu[^D$_Ét~Ѓ3‹t܄t,ttuĉ3҉3t3uwD$[^_UW}3كE8t3_ËU S39]u e=SSSSS0MVu;t!;u6=SSSSS0SE;wMWuEuEBuuPuՏ;tMxEEPSݟYY_^[ËUujuuu5]QL$+#ȋ%;r
Y$-U WV&3Y;ua<WWWWW/49}t޹EIuuM;wEuEuuPU_ËUVuEPjuh0Az^]ËUVuEPuuh0AW^]ËUVuEPjuh@A5^]ËUVuEPuuh@A^]ËUSVuW3;uo;WWWWW.BFt7VsVV輙P}F;t
PY~~_^[]jh0BsM3u3;;u:WWWWWx.F@t~EsVY}V*YEEՋuVHYËUSVW39}t$9}tu;ur:WWWWW-3_^[ËM;tڃ3u9Ew͋}}FM}tFEENt/Ft(;rWu6)~>+}O;]rOtVYu}}t	3ҋu+WuV*YPjta;wM+;rP})EVP臜YYt)EFKEEAEN +3uN EjhPB0q39ut)9ut$39u;u 
9VVVVV,3>qu%Yuuuuu=EEEudYËUEtM]ËUEt8uPY]ËUSVWuM3E苸]ut>~4>E}E}YYM\rҍCP|YueE:4EF+ƍDPV{t3PPPPP*V}E:tEF+ƍDPV{t3PPPPP)VX}E}Yr}_^[tE`pEjYËUSVWuM3{E䋸w8uEv0|6E|uYYMÃM\uuՍCP{YuthEE:wF+ƍDPVzt3PPPPP)V|E:7F+ƍDPVzt3PPPPP(VN|MYu}_^[tE`pEjYËU$SVWuM3rE܋}]t3{43E{E}YYM|rҍF8EE]s0{3E{EYYMM|u{{Ǎ|q{|b{|S{PEz؃WhVSeF])uEESvj
[0A~wII@;r[ËUQSV3҉U9Ut597vj
[0F	~w7NN@;r.;1s(NVtj
[0ENuE)^[ËUQSYVWًI	tptIHt$F3;ulv3;ZQUThEv3;8/UT#%EF3;jY;[QXTMjY+HHt4HHtHuusF3;;;tHF3;;ȋF;w=ml;}3j^;@3;A;FF=|=~~03jdYujkdvm9ZAHHt\Ht,v3;muFjvypujZM.Yu3uSV9}tAjurtsE98tlu EPSVjuH5CW뾋v3;|UT8v3;|~[/WWWWW"3Uv3;|̓ȍF/pteHtFHt&Hu)*.39F ؋EF3;yujdYu3uSV9}tjW
F3;@7u3Bv3;UEO3@_^[ËU B3ʼnEESVu3+WtHtE}
QBu
QBlfPSfUfPfBfUfPfUfPfUfPffES3WfEEPSMfUщE;=;tPGY;t	E;tZuSWEPjUH~!uM>vEECHuY3@e_^[M3Êt]u;t3҉UAB8tMȃdN'AHt~MtOauQ訾YYt;vG8GsMHtHtHt
HuB<b5Em'HtHt	EHhĹBW込YYuhBW証YYu}pp;]<'tEuPǽYYt;vG8GuGHtHtHtHAUaNEd@hHt%HHtHHrYyExE;uPݼYYt;vG8;uP薼YYt;vG8GuaHtHtES.HtHtEMHtHtrEIuUuSut}}3U ESu3ۍM]EE;u+)SSSSSP8]tE`p3PW};u+)SSSSS8]tE`p3Vu;E;u	EE};:ty<%tAMQP)YYt3A9MvF8tpU
EMMEFM/U;twF3>#u@FPuEPEPMtBF9]w9]vE+}8]t\MapSME9]u 9]w("&9]vEq(SSSSS8]tE`p3^_[ËUujuuuuA]ËUjjuuuu"]ËUjuuuuu]jhpB_3ۉ]3};;u'SSSSST3y3u;;t38;tHE;u
'ʉ]8u s'jEPhBJPuVW9EE	E_uYËUj@uu*]ËUVW}3;u&j_VVVVV8$huu;t3&_^]ËU S39]u&SSSSS5ME;tVEEEPSuEPEEBJyMxEEPSVYY^[ËUEPuuuj]ËUEPjuuu]ËUEPuuuu]ËUEPjuuuu1]ËUEPuuuuu]ËUEPjuuuA]ËUEPuuuu"]ËUEPuYY]ËUEPuYY]ËUEPuuu]ËUEPuu]ËUuME~EPhueIMH%}tMapËU=
CuE
BA%]ju~YY]ËUuME~EPjuHMH}tMapËU=
CuE
BA]juYY]ËUuME~EPjucHMH}tMapËU=
CuE
BA]juYY]ËUuME~EPjuGMH}tMapËU=
CuE
BA]juYY]ËUuME~EPhubGMH%}tMapËU=
CuE
BA%]ju~YY]ËUuME~EPjuFMH}tMapËU=
CuE
BA]juYY]ËUuME~EPju`FMH}tMapËU=
CuE
BA]juYY]ËUuME~EPhuEMH%}tMapËU=
CuE
BA%]ju~YY]ËUuM
E~EPhWuXEMH%W}tMapËU=
CuE
BA%W]ju~YY]ËUuME~EPhuDMH%}tMapËU=
CuE
BA%]ju~YY]ËUuME~EPj uODMH }tMapËU=
CuE
BA ]juYY]ËU}]ËUE]ËUuu9YYu}_t]3@]ËUuoYu}_t]3@]ËUuu~YYu}_t]3@]ËUEPYu}_t]3@]̋V;ttSN@Au[^̋UQUW;vnM
SEVIu;w"$SVU~u;vMU;t#t+IN@uMU+;w^[_]̋US]Vuu't#jjjjjn^[]W}v}u$jjjjj=_^[]ÃrNE]u+3@wEPWSvËWSU~UϋtVSU~U΋\VWU~U΋Dd$;v];sWSU~;wI];]wWSU~+u;vWVU;w2Ut#+JUUUU@u;uu;s+u;vWVUt;rI+uE;vWVUtEUʋ++;|+;sM􉄍xAM;s9u}];sM􉜍xAM;s]}uj}EE9xUEڋ;jhBS]uuoYuuSY=`*C3}jCY}S=DYE;;5P*CwIVSPIt]5VNPYE;t'CH;rPSuSCESPD9}uH;u3FuuVW5(CQBE;t CH;rPSuUSuCE.}u1uFuVSj5(CQBu]j2AYË}9=Ct,VVYF9}ulYj=YËUVtЃ;ur^]ËUVu3utу;ur^]ËUMV3;uVVVVV 
jX
C;tډ3^]ËUMV3;uXVVVVV	jX
C;tډ3^]ËU=*Cth*CaYt
u*CY蘷hRBhRB)YYuBh%lARB$RB=*CYth*C	Ytjjj*C3]jhBMjM=Ye3C9CCEC}5|*C4Y}؅tx5x*C3Yu܉}uu;rW39t;rJ6335|*C35x*C39}u9Et}}؉Eu܋}hRBRBYhRBRBYE}u(Cjc;Yu3C}tjJ;YLËUjju]ËUjju]jjjjjjËV2VTPVV?VVZVXV蜷V腷hN@&2$B^ËU=CuOuMhYY]øMZf9@u6<@@PEu%f9@ut@v39@3jXhBtK3uEPQBj_}MZf9@u8<@@PEu'f9@ut@v39@Mu3CS{8YujY5ujY)]ma}jgYQBp*CCJ}jAY}j	0YS`Y;tPY0]tMj
YQPVh@蓎E9uuP}5E	MPQYYËeE܉E}uPEE3@ËeEHJ}xU}uu}MfofoNfoV fo^0ffOfW f_0fof@fonPfov`fo~pfg@foPfw`fpIuu}]U}u]]ÙȋE3+ʃ3+ʙ3+3+uJu΃M;t+VSP'EMtw]U+щU+ى]u}MES;u5كMu}MMMUUE+EPRQLEu}MʃE]u}]jhBHef(E#E=t
=t33@ËeeEEHËU3SEEESX5 PZ+tQ3E]UMUE[Et\t3@3[l*C3U}}Mf$ffGfG fG0fG@fGPfG`fGpIuЋ}]U}E3+3+u-uEFV苼YiE<+t<0|<9F3ۋuj0YÀ>:u8FVVYk<E<9F<0}>:uFV6YE<9F<0}9]t]E;t#jVj@wztSSSSSGun0uX0@ËUe}SVW}%yH@Eujd[ult
BBE+_jd_FjEÙU}+ЋڍGimÍ%[Ek+E;Ut}}ujd[ultEB	EB;~D?%yH@ujd[ult	4B4Buk<M k<M$iM(}u5B
B=BkEP5B
BYt3PPPPP2EiByB\&
B\&9B|)BB=B_^[ËUVE3PuYt
VVVVV9uu3XWS3C;Bu;B95
C
C
CP
CP
CPf95
Cu
CVP
CPRS
CPVVRV
CSWr
C
l
C$Pp
CPn
CPf95d
Cuh
CVPj
CPwSj
CPVVwVf
CV$TkjXjYE]}jXE
EVVVVVQRSSjYEVVVVVuwSVjYH
BB;ȋW};|";;~;}[^;|;;~;}3Gk<Gk<i;u
3;B3;BjhXB<395
Cu*js,Yu95
Cu
CE<jQ+YjhxB<j.,YeE<j+YjhBQ<j+Ye}EE	Ek<j*YËUVuW3};uj^WWWWW0j$hVۯE;tˋ@ME|@Wsj^0뼃|
&AwSWh3PQnȃF+yjd}M؋Ǚ_jh+؋EDAڙRP+jQSRPl}U}M|sGEǀ3UȁEyIAu
jdYuEluAU2EȁyIAu
jdYuEluEEjSuFWfjFhRP贿U}BuBF3A9B}
A9|QIN+jFESp0
jY3ShuWVjFhRP>SUj3[_^ËUVCtuVYY#^]ËUEV3;uVVVVV!jX

B3^]ËUEV3;u\VVVVVjX

B3^]ËUEV3;u#VVVVVjX

B3^]ËUES3V;t:9]v:;tW};tE;t@t;j^SSSSS0WU9]tj^SSSSS0764B6?F@Y9]u3;Evj"X6uu8D_^[]øBøBøBøBËUE3;͈BtA-rHwj
X]Ë͌B]DjY;#] uBÃ uBÃËUVMQY0^]ËUm ujX]M3]ËUVu3;uPPPPPjXp3^]ËU ujX]bM3]ËUVu3;uPPPPPjX33^]WVS3D$}GT$ڃD$T$D$}GT$ڃD$T$uL$D$3؋D$A؋L$T$D$ud$ȋD$r;T$wr;D$vN3ҋOu؃[^_SW3D$}GT$ڃD$T$D$}T$ڃD$T$uL$D$3D$3OyNS؋L$T$D$ud$d$r;T$wr;D$v+D$T$+D$T$Oy؃_[UQSVu3ۉ];uj^SSSSS0)j$hVE;tˋ@W}]j^0̋WiҀyʍF3;|+B;|+ȸB;|B+EVQBFi9]uBF3B9G}
B9|3JV+QFEj_j<^ V_Fiȋ_Fk<+ȉ3^[ËV:uo3^Ã~Duj$@YFDt܋FD^ËUVtuV|YY#^]SVD$uL$D$3؋D$Aȋ\$T$D$ud$ȋD$r;T$wr;D$vN3ҋ^[-t"t
tHt3øøøøËVWh3FWPr3ȋ~~~~BF+ο@Ou@Nu_^ËUB3ʼnESWPvQB3@;rƅ t.;w+@P
j R详CCujvvPWPjj躽3SvWPWPWvS蛻DSvWPWPhvSv$3EtLtL Ƅ@;rVDž3)ЍZ wLр wL р A;r‹M_3[IjhB1$BGptltwhuj Y1j
 Yewhu;5(Bt6tVQBuBtV葭Y(BGh5(BuVQBE뎋uj
YËUS3SM
Cu
CQB8]tEMapE,BD;FG;v}FF>uыuE}urlj{CgjCC4BZf1Af0A@@JuL@;vFF~4C@IuCCSs3ȋ{95
CXM_^3[DËUjM蓧Ext}@tMapÀ}tE`p3jhBC.Mj}_hu7E;CWh :Y؅Fwh#SuzYYEuvhQBuFh=BtP/Y^hS=QBFp$Bj
@YeC
CC
CC
C3E}fLCfE
C@3E=}
L B@3E=}(B@5(BQBu(B=BtPvY(BSE0j
Y%u BtS@YeE,Ã=*CujVY*C3ád*Cøh*CËUSVu3W;to=Cth;t^9uZ;t9uP軨YY;t9uP蚨"YY肨wYY;tD9u@-PV+PC+P5*=Bt9uP\7YY~PE(Bt;t9uPާY9_tG;t9uPǧYMuV踧Y_^[]ËUSV5QBW}W֋tP֋tP֋tP֋tP֍_PE{(Bt	tPփ{t
CtPփMu֋P_^[]ËUW}SV5QBW֋tP֋tP֋tP֋tP֍_PE{(Bt	tPփ{t
CtPփMu֋P^[_]ËVtt;tWj6Y PY_^Åt7t3V0;t(W8YtV>Yu0BtV3Y^3jhB)$BFpt"~ltpluj Y)jYeFl=BiEEjYuËUVWdHpjZBUt:3;t;t'tVVVVVHp
$B_^]áBH
CH
C
B
B
<C
C@CjhBw(uj
YeFtPQBuF=BtP认YE[>tCuW~uQh\Bud.3t
VVVVV(;t
3ffGfG`;t0dGV{0YP;s,VhYYVXYYLlVPYYlPSPCTlPWh>t
P;rL$UB@PVWX蟝t3VVVVV&39\tjS\m9`tjT`Ohudu-t
VVVVVh3M_^3[2ËUB3ʼnESW
uhPPPhxPSu3E0sHxP\YYxxP.PtW-YYptCHM\DklX1jPd
U]jhhBR3ۉ]}v9SSSSS3,SucNp]jh'YY};j
YENl]uMPYE;9]th(BuYYt

Cj@
YE^lWYFpu2$Bu);BljBPh
Cۊme-}܋u3jYËujYW`WYYEE<ËufpËUuQBu]6]ËUV5B5QBօt!BtP5BЅt'tBVQBuVYthdBP$QBtuЉEE^]jYËUV5B5QBօt!BtP5BЅt'tBVQBuVjYthBP$QBtuЉEE^]QBUu5BQB]BËV5BQBu5CEYV5BQB^ËUuu5 CY]BtP5$CYЃ
BBtPQB
BjhB$tBVQBuVnYEuF\(B3G~t$hdBP$QBӉhBuӉ~pƆCƆKCFhBj
_YevhQBE>j>Y}EFluBFlvl2YE3Guj
YjYËVWt~t
WW&YHB|ܾ(B_t	~uPӃHB|^[ËUE4(BQB]t$jRBhYjhB3G}39(CujhYYu4(B9tnj:Y;u3Qj
YY]9u,hW蒅YYuWY]>WYE	Ej
YËUEV4(B>uP"YujY6QB^]Ã=(Cu3á`*C#P*CËUEHVv3VVVVVkjX395(Cuף B3^]ËUEV3;uVVVVV$jX95(Ctۋ
 B3^]ËUh@j5(CQBL*Cu]ËM%C%H*CT*C3
P*CX*C@]ËU
H*CL*CkU+Pr	;r3]ËUMAVuW+yiDMIMS1UVUU]utJ?vj?ZK;KuB sL!\D	u#M!JL!	uM!Y]S[MMZUZRSMJ?vj?Z]]+u]j?uK^;vMJM;v;t^Mq;qu; s!tDLu!M!1K!LuM!qMqINMqINu]}u;MыYN^qNqN;Nu`LML s%}uʻM	DD	)}uJM	YJꍄ	ED0EC
\*C5RBh@HSQ֋
\*CC	PC@
\*CC@HCCHyCu	`CxueSjp֡Cpj5(C|QB
H*CCkL*C+ȍLQHQPE
H*C;CvmL*CT*CEC=\*C[_^áX*CV5H*CW3;u4kP5L*CW5(CQB;u3xX*C5H*CL*Ck5L*ChAj5(CQBF;tjh hWRBF;uvW5(C|QB뛃N>~H*CF_^ËUQQMASVqW3C}i0Dj?EZ@@JujhyhWRBupU;wC+GAH@PǀIuˋUEOHAJHAdD3GFCENCu	x!P_^[ËUMASVuW}+QiDMOI;|9M]UE;;MIM?vj?YM_;_uC sML!\D	u&M!ML!	uM!YO_YOyM+M}}MOL1?vj?_]][Y]YKYKY;YuWLML s}uϻM	DD }uOM	YO	UMD2LUFBD2<38/])uNK\3uN]K?vj?^EuN?vj?^O;OuB st!\Du#M!NL!	uM!Y]OwqwOquuuN?vj?^MyK{YKYK;KuWLML s}uοM	9DD }uNM	yN	ED3@_^[áC
\*Ch@HhQRB
\*CC	PC@
\*CC@HCCHyCu	`CxuH=H*C~?pj5(C|QB
H*CCkL*C+ȍLQHQP;
H*C%CËUL*C8S3;u9H*CVWỦ]kB;gJMDM܋JM]]]uj@39]Y]؉]]9]U:tIEH?~j?X19x;rClE}93e_C}ԉ];M;tM;d;Vȁ;1;tˋ];u;I?~j?Y;M9HEEԋ@;u}t! }	E	EN	E	EE9xM;9F@uȋU3ۋE;FE;EEeE} uE;u_E;BuWEE;H*CU3_^[j6j2j.j*j&j"jjjjjj
jjjX뾋UV395(Cu3`*Cu.E=v]VVVVVˣP*C3@]W};tBuBwWYuVVVVV襾 =P*C`*C3@
3_^]ËUH*CMkL*CMSI VW}M
3U
T*CS;#U#u
];r;uL*CS;#U#u
];r;u[{u
];r;u1L*C	{u
];r;u@؉]u3	SYKC8tT*CCUt|D#M#u)eHD9#U#uEUiDMLD3#u#Mj _G}MT
+MN?M~j?^;J;Ju\ }&M|8Ӊ]#\D\Du3M]!,OM|8!]u]M!K]}JzyJzyMyJzQJQJ;Ju^LM L}#}u	;οM	|D)}u
N	{MN	7Mt
LMuэN
L2uy>u;CuM;
\*Cu%CMB_^[hPAd5D$l$l$+SVWB1E3PeuEEEEdËMd
Y__^[]Q̋t
O30AuOG301űUS]Vs35BWEE{t
N38tNF38tE@fMUS[EMt_I[LDEEt`E|@GE؃u΀}t$t
N38itNV3:YtE_^[]EɋM9csmu)=@*Ct h@*ChtUjR@*CM[`E9XthBWӋ^`EMHt
N38sNV3:sEH_9SRhBW	`UQQS]VW33};HBt	G}rwj,Y4jYu
=BAhpBSCW6	t
VVVVV脷hCVj
CPBu&hXBhVt3PPPPP@V
@Y9MuH9Ut
@ff;u9Mu8]tMap8]tE`p3^[ËUjuu2]ËUEVW|Y;8)CsQ<@)C<u5=BS]utHtHuSjSjSj\PB3[`	h _^]ËUMS3;VW|[;
8)CsS<@)C@t58t0=Bu+tItIuSjSjSj\PB3ڷ	_^[]ËUEuƷ 諷	]V3;|";8)Csȃ@)C@u$腷0kVVVVV	^]jhBK}4@)CE39^u6j
Y]9^uhFPdYYu]FE09]t@)CD8PQBE3ۋ}j
sYËUEȃ@)CDPQB]jh0BM3}j]YubjY}}؃@<4@)Cu@)C;Fu\~u9j
Y3C]~uhFPbYYu]Fe(}u^SQBFtSQB@낋}؋uj
pYÃ}uF+4@)Cu}uyG+j@j 3YYEta@)C8)C ;s@@
`@E}σ@)CDWYuME	EEjYjhXB3}2Et E@tˀEtuQB;u%uN@	uNhFP_\YYt7F
N@Cg58)CpQB33@ËeEgËVW@)C>t1t
GPRB@;r6Uc&Y@*C|_^ËUVuV9
PYYt|m ;u3m@;u`3@CFuNSW<C?u SYuFjFXFF
?~>^^N3_@[3^]ËU}t'VuFtV7ff&fY^]A@tyt$IxQPYYu	ËUVMEM>t}^]ËUG@SVt2u,E+M}C>ul8*uϰ?d}^[]ËUE@]ËUEAQ]ËUEf@]ËUxB3ʼnES]Vu3W}u]u5説3PPPPP4t
`p
F@u^V
YBttȃ@)CA$uttȃ@)C@$g3;]
C
, If90t@@;u+(;uPBI8t@;u+\@t2t	ƅ-t	ƅ+tƅ Dž++uSj 6<YtuWSj0tf~bPjEPFPF蹷u(9t MYuPY|tWSj HtqVYtt
`pM_^3[cOÐ !A!AQAAA AL Az!AUEV3;unVVVVV@^]jhBM3u3};;u ,VVVVV踔39u;tԉ}W:`YuG@uwWjYttȃ@)CBA$u)tt@)CB@$t蒠VVVVVM9uu"WuuuWUEWV)E	Eu_YËUuuuuhA]ËUuuuuhA]ËUuuuuhA]ËUujuuhAk]ËUujuuhAL]ËUujuuhA-]jhBu3ۉ]jY]j_};=:C}W*C9tD@tPdYtE|(*C PRB*C4|SY*CGE	E1jYËUSVuFȀ3ۀu@t9FW>+~,WPV#YPc.;uFyFN _Ff^[]ËUVuu	V5Y/V|YtF@tVPYY3^]jhB&3}}jY}3u;5:C*C98t^@tVPV]]YY3BU*CHt/9UuPJYtE9}utP/Yu	E܉}F3uࡌ*C4Vf]YYE}EtEjYjhBL39uu	V
Y'ui\YuuYEE	EUu\YjYËUQVuVaEFYuӜ	N /@t
踜"S3ۨt^NFFF^]u,Z ;tZ@;u
u^YuVhYFWF>HN+I;N~WPu+EM FyMtt@)CB@ tjSSQ#ƒt%FM3GWEPuu+E9}t	N E%_[^ËU9EuFjP;Mu+2YYu3]ËE6u7CQtՉ&3@]ËUE]ËUEPwEYu߃]Jx	
A
R9YËU}t]A]ËUSU؃tPxYu[]ËUB3ʼnEMEV3W}|dTDž$^0x;u TVVVVV5;t@@SuzPYBttȃ@)CA$u&ttȃ@)C@$t ϙVVVVV[uJƅct<kdPHwYt0tVVtYPkYYGPwYu
<%1
8G
3@ƅ/XLlƅaƅ`ƅjƅSƅbƅsƅk(GPuYtlLk
DЉlN*tpFItLutkO6uG84u(48m3uG82u\dtWitRotMxtHXuAj9ht(lt
wtS"G8ltksksSjHu032ۉD8su]u	]FE f/^F<-uBt>]t7F:sŠ:w"*ЋσdzDGJu2ȊЋD<]uHDx+u'lutdtCxj0^9xxdtxf>HcGH`<%u
G8%utGxH;ulPYt!tGH;uGtxu?%uDHxnu8	*dxYYVSVPVSy0uT?Yxu* ntJct{tdtOYdtxDT@t
l,quAct
st{u2 @D4ocdg~Bit!nxqt	
jd_x-PƅaM3ۃx-u\-C	x+uldtx@ulxklltfx\X0P|PCS\(edtpxPaYub:xlldt\xb0P|PCS\(h
xklltf\xX0P|PCS\(^
dtixP`YuX_xet
xEIll5\e0P|PCS\(|	dtx-u,\-0P|PCS6		x+u/llu!ldtnxxklltf\xX0P|PCS\(dtxP6_YudtxXYYqL\<QPDkHP5tB賠YЃulDž@r~ƅjdtVxPMYYct4@tllBtxctLsu	|	
 u4{b3ҋȃBL
3ϋq4)j$P"YttX%PDž?$PPfffCCǃpHH}t3;xYcqX Gr~ƅjF>^uFƅbj EjP,>]u	]FE r/jF<-uHtD]t=F:sŠ:w(*ЋσdzDGJu苽2ȊЋD<]uDTx+u,lu
t	ƅsdtxx0tdtxxPXYoux88<8k
1xPXYtbx8x8YxX@DЉ8tlt5dtxDdtxYYa8ktfTcFTn<%u
F8%udt4FxT;PYt%tFT;txu>%TxnBdxYYr~3fz`dxYYDžAyjt
P3f PWSWP t tjVhBҶF> t>=upF> tjhBV uMAjhBVuM!jhBVuMF> t8thSSSSS3\huEuuPGt3 ECMHMXXXH_^[jh`BH33}jY]3u;5:C*C9t[@uHuAFwFPY*C4VW'YY*C@tPV'YYF둋}hj8$Y
*C*C9tIh PYY*Cu4Y*C PQB*C<}_;tg___OEnË}j؍YSVWT$D$L$URPQQh4dAd5B3ĉD$d%D$0XL$,3pt;T$4t;v.4v\H{uhCjC|d_^[ËL$At3D$H3!Uhppp>]D$T$UL$)qqq(]UVWS33333[_^]ËjǴ33333USVWjjhdAQ_^[]Ul$RQt$]U S39]ueSSSSS7YNE;tVuEuEuEPEEBKMxEEPSWYY^[ËUujuum]ËU V39uueVVVVVX'uEuEuEBPuuU^ËUujuhA]ËUuuuhAu]ËUujuhAY]ËUuuuhA<]ËU S39]u JdSSSSSWVuW};t!;udSSSSSWjE;w}uEuEBuuPuUE;t4;|"MxEEPSYYtE39]\>HH_^[ËUujuuuhA}]ËUuuuuuhA}]ËUS39]u.cSSSSSV[Vu;t9]w
c0uuuuVhA;}ub"SSSSS^V^[]ËUujuuu`]ËUQS39]u bSSSSSVVuW9]u;u9]u3;t};wCb3buuu;}v-8E@PVhAuLb8"uea8\WVhAE\>u}ua8"u/aM#;}"ua"SSSSS;U_^[ËUujuuuu]ËUujuuuhA}]ËUuuuuuhA}]ËUVuW3;uaWWWWWTF@t FFu	VؚYFvvV)YPRF;FuOVYt.VYt"VV<@)C׾YYB@$=u	Fd.=u	Fd=u	Fd=uFdvdjY~d`QӋEYF`[_^ËUcsm9Eu
uPYY]3]ËUECCCC]jhB莒3W2Y}9}uC5CyEEC5CxEEY;ttxE9}u33WӀYÃ}tuUY3@GUE
BV9Ptku;rkM^;s9Pt3]5CdxYzdz`jh B蝑eu]j_;tt	y(B9~\u'5B苝YF\g5BWPv\YDPM%H=Bk~\;	9Xtj\Ye;tu>=Cu5jh&pAQB3A;u
CX5CvYE;t,VvC5CvYE;tVuCYE}uUB]jd~YÃt.t)
t$~~W3PPPPPK貏j h@B`3}}؋]LtjY+t"+t+td+uDw}؅uaCC`w\ZÃt<t+HtV3PPPPPqJ뮾CCCC
CCEPQuEY3}9EujB9EtP/~Y3Et
tuO`MԉG`u@OdMGdu.
BM܋
BB9M}MkW\DEtEuwdSUY]}؃}tj|YSUYt
tuEԉG`uEЉGd3ËUEC]ËUQVW5CAtE3Y;uUj_VVVVV8
IS0;hB QBE;uEUj_VVVVV8HhBP$QB;u/U==Yt1jS=YYtNVSPEt3PPPPPC>u5C%C't*C3Y[_^5C%CUEC]ËUQMS3VU9Et	]EE>"u39E"FE<tBUPF
Yt}t
MEFUMt2}u t	utBe>< t<	uFN>}t	EE3C3FA>\t>"u&u}tF8"u
339EEtIt\BuUtU}u< tK<	tGt=Pt#(Yt
MEFME
YtFUFVtBUME^[t ËUS3VW9*CuZhCVSCPBp*C5C;tE8uuUEPSS}
E=?sJMsB;r6P_Y;t)UEPWV}EHC5C3_^[ËUCSV5PBW33;u.֋;tC#gE;t9]w9]u;tWu+Y;t9W@Y9]t*;Evj"X"Wuut
SSSSSB<3_^[]ËUQVW3;uIj^WWWWW0}=wE;;t89}tuYE;tUPmFjV;uII)uVPXt
WWWWW;E;t03_^jhB\339u;u@IVVVVV<3>Wu_YY;tjpYuuYEE	E4joYjhBـj~pY3ۉ]3};;uHj^0SSSSS=<uwM;t	9]w	;u
9]u3@3;t;tuJY;t=VY@9]t.;Ev	E"#Vuu;t
SSSSS]:]E	E\jnYjhBjoY3u3];;uGj_8VVVVVe;}3E;t039u;tuYE;tXPJGjWæ;uxGmGE*uWP2;t
VVVVV9E;t8uE	EvjmYËULB3ʼnES3VuW]ԉ]]]؉]܉u]9^F9u PF0hPESP.j1jWEfjWE[jWEPjhEA$E9]|9]s;k9]b9]YEԉ3M܈@=|EPvQB/}%EE~-8]t(E:txM G;~@@8XuۋESSvPhu܉EjS	 MESvWQW@PhvS$ESvWPEW@PhvS$`E}3҃}fU؉Mč_ZMMȈ~S8]tNMM:tBI;ʉM'HMEfAAM̋M	9M~MAAM8YuhQPSjPWDEjQP2$;tKPQBu@-P+P+PEEEĉEEȉEЉuvYmuiuauYuQ3ۃCˍ;tPQBdžBdžPBdžBdž3M_^3[Wuuuju օ5PBSSWuuu֋ȉM;Et)9];MuuWuuu;~Ej3Xr9D	=w;tjPeY;t	3;tAuVWuuuPBt"SS9]uSSuuuVSu QBEVYuEYY]]9]u@E9] u@E u耟YEu3!;E SSMQuPu 螟E;tԋ5PBSSuPuu։E;u3~=w8=w;tPOY;t	3;tuSWfuWuuuu։E;u3%uEuPWu uu#uWwYuuuuuuPB9]t	uaYE;t9EtPNYƍe_^[M3ËUuMu(Mu$u uuuuu( }tMapËUQQB3ʼnECSV3W;u:EP3FVhBVPBt5C4uESPPj?uESPPj@uSEPPjAuESPxPPjBuESP]PjCuESPEPj(uESP-Pj)uESPPPjuESPPj uESPPhuESPPh	]SEjPP_[ËUVuvvvv}vuvm6fv ^v$Vv(Nv,Fv0>v46v.v8&v<@v@vDvHvLvPvTvXv\v`vdvhvlvpvtvxv|@wlaVK@5*,^]ËUSVW} Bt@hj<{YYu3@EtV+VYYdž;tPQB73_^[]28tSV<0|<9,0A8u^[<;up8uUVut5;CtPPYF;CtP>Yv;5CtV,Y^]ËUS]V3W]u9su9suuuEC:j0j2zYY};u3@wjYjy3YE;uuYщ09sjyYE;u3FuuYY0u{>VjWEjPPEFPjWEjP;	EFPjWEEjP#<EtVY뎋E0|9
0@8u7;u~>u
CE
CH
CuHE3AEt5QBtP֋tPօuYYEEE3_^[28tSV<0|<9,0A8u^[<;up8uUVut~F;CtP
YF;CtPYF; CtPYF;$CtPYF;(CtPYF ;,CtPYv$;50CtVY^]ËUSVuW3}u}9~u9~u}}C6j0jwYY;u3@ujJwYE;u	SujYCEu	IK@MC3@39}tM;tPQB;t#PQBuYYEE3_^[3QHl;
Bt
$BHpu><CËUES3VW;t};w0j^0SSSSS#EÙ+‹E<7E0YYu
M9}Nu^;]~_^3Ʌ[]ÁNPBFFËUB3ʼnEVtS>tNhBV+YYt=hBVYYujEPjwPBt/uVYM3^OjEPhwPBu3׍EhBPYYuQB뻋U3fMf;Bt@@r3@]3]ËV3#,aB<w,A<wtЊ
u׋^3
BA|Z~aw@ËU|B3ʼnEVW}OׁƜjxEPF%PWPBu!F@2EPv1YYuWYt
N~~FЃM_3^U|B3ʼnEVjxEPE%j
PPBu3.U9Et}t6WVrY;_t3@M3^ËU|B3ʼnESVW}MׁƜyPBjxEPF%PWӅuf3@bEPvYYjxEPF%PWӅtEP6YYuN~RFuOFt,PEP6zu6N~qY;Fu!~VuWYt	V~N#;jxEPF%PWӅEP6AY3Yu/NF9^t

FG9^t;6qY;Fu.j9^u49^t/EP6YYuSWYYtN9^u~FЃM_^3[U|B3ʼnEVW}#LׁƜjxEPF%PWPBu!F@[EP6TYYu	9Fu0j~u0~t*EP6.YYuPW$YYt
N~~FЃM_3^voYj@hӜAFPBFuf6ov@Fof@~YYFtjXjhߝAFPBFttuf6do@YFtjXjhAFPBFufËUSVWJ]ƜuNC@~t8tWjhBftS8tNt8tS~Vj@hB}tb?t?tPI?t0?t+WvnYj@hӜAFPBFufFPBFF~˃#ˋn}PQBjvPBEtfNffNfHfx]tm=PBf9u%hBj@Skt"3PPPPPj@Shvׅt,j@C@Phvׅtj
jSu;3@3_^[]Åt
3ɅL		+t
3ɅL	ff;t5+t3҅T…uFI+t3ɅL	3Ë;to+t3҅T…uVFQ+t3҅T…u9FQ+t3҅T…uFI+t3ɅL	3ËVW^;tx+t3DqB+t3DqB+t3DqB+t
3D3A;BtyB+t3DqB+t3DhqB+t3DIqB+t
3D3"A;BtyB+t3Dq	B	+t3Dq
B
+t3DqB+t
3D3A;BtyB+t3Dqq
B
+t3DRqB+t3D3qB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3A;BtyB+t3D[qB+t3D<qB+t3DqB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3kA;BtyB+t3DEqB+t3D&qB+t3DqB+t
3D3    ׃$(AA;BtzBq+t3DqB+t3DtqB+t3DUqB+t
3D3.A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3A;BtyB+t3D}qB+t3D^qB+t3D?qB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3A;BtyB+t3DgqB+t3DHqB+t3D)qB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3u{A;BtkB+t3DuYqB+t3Du>qB+t3Du#AJ+t3ɅL	3u3_^ËA;BtmB+t3DuqB+t3DuqB+t3DuqB+t
3D3uA;BtzBq+t3D[qB+t3D<qB+t3DqB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3kA;BtyB+t3DEqB+t3D&qB+t3DqB+t
3D3A;BtyB+t3DqB+t3DqB+t3D|qB+t
3D3UA;BtyB+t3D/qB+t3DqB+t3DqB+t
3D3A;BtyB+t3DqB+t3DqB+t3DfqB+t
3D3?AJ+/3ɅL	A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3A;BtzBq+t3DkqB+t3DLqB+t3D-qB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3{A;BtyB+t3DUqB+t3D6qB+t3DqB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3eA;BtyB+t3D?qB+t3D qB+t3DqB+t
3D3A;BtyB+t3DqB+t3DqB+t3DvqB+t
3D3OfAf;B?A;BtzBq+t3DqB+t3DqB+t3DqB+t
3D3A;BtyB+t3DqB+t3DkqB+t3DLqB+t
3D3%A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3A;BtyB+t3DtqB+t3DUqB+t3D6qB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3A;BtyB+t3D^qB+t3D?qB+t3D qB+t
3D3A;BtyB+t3DqB+t3DqB+t3DqB+t
3D3nqB+t3DOqB+3DIRAAAA٫AAzA[ARAAAжAǪAtAdAEA=Yt1jW37YYtPVWPt3PPPPP4~f>u5C豦%C#t*C3Y[_^5C苦%CVPB3;u3^f9t@@f9u@@f9u+@S@WSI6Yu
VPB_[^SVWMUEfUf;t@@fuf9t3]ËUSuM薢M3;u8]tE`p39]u.OSSSSS8]tE`p9]tV;vSSSSS?E9XuuQuu
[6pQuQuhpEPZ ;u8]tE`p8]tMap^[ËUjuuu]ËUS39]u3AVWu6FV-YY;t"uVW!4t
SSSSSo3_^[]ËUQQSV3W=Cu;teQBVVVVjPVVӉE;tTjP4YYE;tCVVuPj7VVӅt6EVPW1YY}9utu2Yu;u3_^[ÃuYjhB'M3;v.jX3;E@ulWWWWW3Mu;u3F3ۉ]wi=`*CuKuE;P*Cw7jY}u*$YEE_];tuWS;uaVj5(CQB;uL9=Ct3VG+YrE;PE3ujUY;u
E;t&ËUMS3;v(j3X;EsWSSSSS3AMVW9]tuCYVueYYt;s+VjS_^[]ËUEu	3]V3;|;8)CrVVVVV	X3ȃ@)CD@^]jhB%339u;uyVVVVV_ëj [PjάYYu謫Ps>YEPVu蔫P@E脫PW>E	EK%^ Pj٬YYËUEPuuX]ËUEPuuX]ËUEPjuX]ËUEPuuX]ËUEPjuX]ËU
BU39
C#щC]áB39CËUSVu3W};u;vE;t3E;tvj^SSSSS0yVuME9XfEf;v6;t;vWSV誗*8]tMap_^[;t2;w,nj"^SSSSS08]yE`pmE;t8]%E`pMQSWVjMQS]pQB;t9]^M;tt}^]ËUG@SVt2u,E+M}C>u8*uϰ?d}^[]ËUxB3ʼnES]Vu3W}u薙u5l3PPPPPt
`p
F@u^VFYBttȃ@)CA$uttȃ@)C@$g3;]P
C39
ʀ Xw
 Bk	@Bj^;jY;	$A3t	ƒ tHt4+t$HHtV		K	?	3	$		*u,k
ʍDЉ*u&k
ʍDЉzItUhtDltwbS;luC8,  <6u{4uCC<3u{2uCCYYu	ËUVMEM>t}^]ËUG@SVt2u,E+M}C>uS8*uϰ?d}^[]ËUEAQ]ËUB3ʼnEES]VuWu3;u3WWWWWAt
`pF@u^V8YBttȃ@)CA$uttȃ@)C@$i;apu9E3pF39N, %uRj
PV~08$u%9uh@0WP9u`j
PV蹌HQ9u(;9$d;~$1B
9u99ƒ tIt5t%HHt~r	gXL*9u@j
PVSHQ9uL;9$dx;~099j*S14;lj

k
ʍDЉi
^
*9u@:j
PVhHQ94;ljƄ8*<k
ʍDЉItUhtDltw>luFnb V<6u~4uFF3<3u~2uFF@Dž
9?Q@jQi9}Dž
u$gu9u]l9~9~̋]VY;t뛃cY4Ht@xPPtP5pBiYЋt%9uP5|B5YYYgu!;uP5xBYYY8-uDžDž$sHHDž'DžQƅ0Džc9099u;jtd9cc9u)099ujT4Qd @tO9u@c949u@sc94E@tD9u@'c|9tD4x9u@\c89u5099uSQ43@t;|;s؃ځڋu3ۃ}Dž9~u!ut-RPSW09~N뽍E+Ft΀900@c94tO;uTB$8+;tE0@@}uE#u	M	EE#;tD=t)=@t"=t)=@t"=t=@uEM#;u	E]EE@]E#=@=tw;E;yvv0fE3H&HREEjSS6tSSS6#ƒjEP6utk}uYEE;bPjSS6CSSS6#ƒE%=u6[@Y]j^0d=uSj6P)EASS65)EEE+PD=P6H9}ۋ@)CD$2M0@)CD$M
ʈ8]u!Etȃ@)CD }#;u|EtvuHQBSuEjPuWu8QBu4@M}ED%
u$L&
t9]t@MED&
SMQuP4QB{M;p;MgMD};t
M9
u ]EÉ]E;M<<
tCAMEH;sA8
u
AAM
uEmEjEPjEP4QBu
9ur9w}v1轡E"t
MMEt	e]MuE^tMEtEM؃ىEM}tEЃ`pEU_[ËU3Puuu9
CuhBPC]ËUjuuuu&]ËU=
CjuuuuhBj]ËUjuuuu]ËUQeVEPuuu9Et薠t
荠M^ËUB3ʼnEjEPhuEPBu
EPnSYM3MËU4B3ʼnEEME؋ESEЋVE܋EW3M̉}};E_5QBMQP֋(QBt^}uXEPuօtK}uEuEuulYF;~[wSD6=w/_;t8-WWuujuӋ;u3P3UY;t	E}9}t؍6PWuDKVuuujuӅt];tWWuSVuWuQBt`][QB9}uWWWWVuWuӋ;t=t7=t0=t)=t"'3SSSSS豀Eu
	3;|;8)Cr
	뻋<@)CL1tPfY]D0tuuYYE萌	ME	EuYUWVSMtMu}AZ I&
t'
t#:r:w:r:w:uu3:t	rً[^_%xQB%|QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%QB%RB%RB%RB%RB%RB%RB%RB%RB% RB%tQB%pQB%hQB%dQB%`QB%QB%QB%QB%QB%QB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%PB%0QB%PB%PB%lQBUVut!;ut;uuu$u uuuG|^]ËVWjV3Y@PYYt,Єt"uFG@Fut	R:>Y3_^j hB3u܉uЉuj菰Y]hBVEPA;tu
VVVVV{;9uVuYY}໬SB9utuYEWM܍DEjPRu؅WuVX3;t
QQQQQ{WYD8EԊ<\upj\WYY9ESuV|X3;tpSSSSSza};tVWYY>VSBSYYu*LB 2&\2BVfv6|lVD.
v^Dv`TB4$~6N`r0F`l(6N^nz"th>~p^LZ.d>P$@@@{kAZxAz7BCBՉ@ITCreateDirectory (%s)MapViewOfFile (%s)CreateFileMapping (%s)CreateFile (%s)inflateEnd returns %dinflate returns %dinflateInit2 returns %d1.2.3\message_boxdirectory_createdfile_createdget_root_hkeyget_special_folder_pathcreate_shortcutCSIDL_FONTSCSIDL_PROGRAMSCSIDL_COMMON_PROGRAMSCSIDL_STARTUPCSIDL_COMMON_STARTUPCSIDL_DESKTOPDIRECTORYCSIDL_COMMON_DESKTOPDIRECTORYCSIDL_APPDATACSIDL_STARTMENUCSIDL_COMMON_STARTMENULib\site-packages\DATAScripts\SCRIPTSHEADERSPLATLIBPURELIBInstallation failed.no such folder (%s)unknown CSIDL (%s)sSHGetSpecialFolderPathAfunction not availableshell32.dllFailed to create shortcut '%s' - error 0x%xSetWorkingDirectory() error 0x%xSetIconLocation() error 0x%xSetArguments() error 0x%xSetDescription() failed, error 0x%xSetPath() failed, error 0x%xQueryInterface(IPersistFile) error 0x%xCoCreateInstance failed, error 0x%xsss|sssiCoInitialize failed, error 0x%xissiSOFTWARE\Python\PythonCore\%d.%d\InstallPathPYTHONHOME=%sOSErrorValueErrorbuiltinsPyLong_FromVoidPtrPyErr_FormatPyArg_ParseTuplePy_BuildValuePyCFunction_NewPyObject_GetAttrStringPyObject_SetAttrStringPyImport_ImportModuleRunning Script...Could not open postinstall-script %s
Py_FinalizePyRun_SimpleStringPySys_SetArgvPy_Initialize*** Could not load Python ***PyErr_PrintPy_SetProgramNameOut of memory!Running the pre-installation script failed
Can't load Python for pre-install script (%d)Runtime Error100 Made Dir: %s
.py200 File Copy: %s
Error200 File Overwrite: %s
Could not create temporary file~duInvalid cfgdata magic number (see bdist_wininst.py)Times RomanSetup %sCould not register window classSetup.exeSetupWindowClassThis Wizard will install %s on your computer. Click Next to continue or Cancel to exit the Setup Wizard.Software\Python\PythonCore\%s\InstallPathPython Version %s (found in registry)Software\Python\PythonCoreDon't know Python's installation typeStrangepython%d%d.dllPython Version %d.%dCannot installNo Python installation found in the registry.Python version %s required, which was not found in the registry.Python %s is required for this package. Select installation to use:UninstallString"%s\Remove%s.exe" -u "%s\%s-wininst.log"wb%s\Remove%s.exe040 Reg DB Value: [%s\%s]%s=%s
Could not set key valueDisplayNamePython %d.%d %s020 Reg DB Key: [%s]%s
Could not create key%s-py%d.%d999 Root Key: %s
Source: %s
*** Installation started %Y/%m/%d %H:%M ***
a%s\%s-wininst.logCould not open keyYou do not seem to have sufficient access rights
on this machine to install this softwareHKEY_CURRENT_USERHKEY_LOCAL_MACHINE*** Installation finished %Y/%m/%d %H:%M ***
Postinstall script finished.
Click the Finish button to exit the Setup wizard.*** run_installscript: internal error 0x%X ***
300 Run Script: [%s]%s
\Scripts\-installPlease wait while running postinstall script...IsUserAnAdminSetupFailed to start elevated process (ShellExecute returned %d)runasif exist "%s" goto Repeat
del "%s"
:Repeat
w%s.batCould not delete keyCould not delete valueuninstall-script*** Could not run installation script ***-removeUninstall Finished!%d files and %d directories removed%d files and %d directories removed
%d files or directories could not be removed%d Run Script: %s%d Reg DB Value: %s%d Reg DB Key: %s%d File Overwrite: %s%d File Copy: %s%d Made Dir: %sYou do not seem to have sufficient access rights
on this machine to uninstall this software%d Root Key: %sOut of memoryAre you sure you want to remove
this package from your computer?Please confirmcould not open logfiler2. arg is not -u-uWrong number of args%s%cimport py_compile; py_compile.compile (r'%s')Py_OptimizeFlagPySys_GetObjectCompiling files to .pyo...Loading python...Compiling files to .pyc...Failed to unzip installation filesInstalling files...Running pre-installation scriptReady to installClick Next to begin the installation of %s. If you want to review or change any of your  installation settings, click Back. Click Cancel to exit the wizard.Bad user_access_control valueoopsnoneautoforceuser_access_controlinstall_scriptmetadatanametarget_versiontarget_optimizetarget_compilebuild_infoinfotitleSetup program invalid or damagedThis program is normally started by windowsRemoveCould not open archive0w,aQ	mjp5c飕d2yҗ+L	|~-d jHqA}mQDžӃVlkdzbeO\lcc=
 n;^iLA`rqgjm
Zjz	'
}Dңhi]Wbgeq6lknv+ӉZzJgo߹ﾎCՎ`~ѡ8ROggW?K6H+
L
J6`zA`Ugn1yiFafo%6hRwG"/&U;(Z+j\1е,[d&c윣ju
m	?6grWJz+{8Ғ
|!ӆBhn[&wowGZpj;f\eibkaElx

TN³9a&g`MGiIwn>JjѮZf@;7SŞϲG0򽽊º0S$6к)WTg#.zfJah]+o*7Z-A1b62S-+ldEw}ZVǖAOIъOM~-QJ#SpxAaU׮.7׵Y-6]]wll?AԞZ͢$ Faw$eڪ]]FD(koipvk19Z* ,	m86F߲]qTp0ek*1u4yީ%8S1bSWĔՖk1**ykʬHpo].*F6fcTT"eM©g0&):{ϼkZ>	8$,52F*sw1pHkQ6Fzw]cN̵J#pAF]#l8?1(BOgT~yUbL8^#ܖTZ1ObbSyOIV~P-{b-R4٠~^eGnHl/Su6:	#jT$+e?yHf'*b#ٽЧ
?&~?$pi;FBzw[keZ~7	Sv8H	3?r$7jnԄYFܨ	|OQ;օ
Ud	S
-
=G\p&Gw)`/a߫i5&LsZ<#0zMzFM8,9;:R:(q-v,.7/pXqYs3r%w+OQvrtEux܉~OK
}!b|tyBxʠz{.lD~m8onlk[wjR1h58ib?mcf+aQ`צedd"fig HINSKyuJcO	NZLݘMFGN@E$DD2AsX@*IBCPhTg3U>uW	ַVS:R|P~Q9ZS [fYX4])\ZEo^m/_5qϱ٥s\ۼqދ!K7kfֶԁ-b3Πjp]$^'~*I@VW<âM˟ŏ{tDCm-@wm.B+(铜>Td"ŀǼϭ~8y$owJ1}05_K^
iϏ은BI#ƈdX܁T̓cQ:
rՆ⩗ fn|xK)o%ƭ/3vUuA?)C:|sĵ@͂Ͳ;bIUeh"׻_HS1޼^Z4eg	Wb27_k%8ם(ŊO}do׸Jj3wVcXWP0qB{߭gCru&op-?'Bs ưGz>2[Ȏg;
i8P/_Y=чe:ZO?(3wwXR
@hQ+ğH*0"ZOWoI}@mNП5+#*'G| AH=XX?#1jvʬ`p^Y<L~i/{kHwâ
hs)aLoD~Pf7VM'(@ﰤہg9x+n&;f?/X)T`D1ߨMߒ.FgTp'Hq/L0UEc?kǃh6ry7]P\@TN%s7@'>$!AxUʰ\3;Y^U~PGl!;b	F2ȂpԞ(Q_V:1X:	n3
m:@/)IJNv"2x+ٗ Kx.HҥfAj^y9*O]#kM`~b_R	7zFh!1߈Vc0a"j6nS	Nr)Υ{t*F8#vufz`rs"WG9^EMvc΍&DAdQy/4Aڱ&S֚EbiLQ<6'5P..T&q]w4.6IE? v\[YI>U!lDa>Ԫ΋ϩ7~8A]&nv|oY
yKiw\¹9~$66nQfq>,o,IӔ	渱{I
.H>C-Yn馑gQztafw0a,	Qmpjc5dۈ2yܸو	L+~|-dj qHA}mԵQӅlVdkbze\Ocl=c
;n Li^`Agqr<KG
k5Blۻ֬@2lE\u
ϫ=Y&0Q:Qa!V#Ϻ(_ٲ$/o|XhLaf-=vAq *q3xɢ4	j
m=-dlc\kkQlabe0bNl{WeP|b-I|LeMaX:QΣtԻ0JߥA=ؕפmCij4ngF`D-s3
L_
|Pq<'A Wh% of	a^)ɘИ"רY=.
\;l tҚG9w&scd;
mj>zjZ	
'}DhibW]egl6qnkv+zZgJoC`֣ѓ~8ORѻgWg?H6K
+گ
L6JAz``ègU1nFiyaf%oҠRh6wG"U&/ź;(+Z\j1,ٞ[ޮd°c&ujm
	6?rgWJz{+8Ҏվ
|!Bhݳڃn&[owGwZjpf;\ebiaklE
x
NT9§g&a`IiGM>nwۮjJZ@f7;𩼮S޻G0齽ʺŠS0$6TW)#gfz.aJ]h*o+7Z-1A26b+-Sdl}wEVZOAي»IˬO~M-JQS#xpaA.U7Y-۩6˚w]]llA?Z$㧲F waރ$Ųe]]DFok(vpi91k *Z	,8mF6]pTqke0*1¶u4%y<8syjHA}X*ݹ1SbSW§ٖծ1k**kypH]oF*.f6TTcMe"¤0g)&Ůޟ:{kZ	>8,$5*F21wsHpQkzF6c]wN̵ׄJ#pȄA#]F8l1?(gOB~TUyLbˁ8#^TO1ZbbySIOP~V{-b-4R^~Ge­lHnuS/:6#	$Tj?e+y䏼Hf*'˼Ѝb#
&??~p$iBF;[wzek~ZS	7H8v	?3$rj7nFY	|OQ;
U	dؓS
-
\G=&pGw`)/ai5&sL<:R=Pe6^X7}o5641W0ճ2k3$k%'1&-[#bML"'{ "!$*x(+)`F(>
q-q,v.Ț/7pqXsYr3w%vQO+tru՛E~xKO}
|b!ytxBz{l.m~Do8nkljw[h1Ri85bcm?a+f`Qeddf"giH IKSNJuyOcN	LZMݥFĚGE@ND$A2D@XsBI*CThPU3gWu>V	SR:P|Q~Z9[ SYfX]4\)^oEZ_/m5qs<\kg2z
&J8 좞V`a/6i\lU,zB\uHƒ=&FW	A+Ox]`غ7W>9q߳!7Kk֩fض-bѠ3pj$]^Ĝ'*~@IWVÕ<ӂMʏş{Dt͆mC-@mw+B.(>dT"ş~Ϝ8yo$w1J}50K_
^ϋiBۉI#dXфTQc:r
Р fΫnx|)Ko%3/uUv?A)ġ:C|sд@͉;IbeU"hH_S1ފZ^ھ4ge	ȋbW72%k_ܝ8Ŵ(}OodJֿjw3XcVPW0Bq{gǧurCo&p-?О'sB zGɠ2>[
;g/P8i_Y=嗇e:ϏOZw3(?RXw@
Qh+HZ"0*WOIo@}m5N#+'*GA |􏒨HX=#?X1vjʨ`^pYL'!$UxAׯ3\Y;U^GP~b;!lڇF	2p(ԐQV_:X1:	3n
:m@I)/NJ2"v+x xKH.jAf^O*9y]#Mk~`bю_޶	Rz7hFм!10cV"ajحn6	SrN){t*8Fv#fu`zrϮsɛW"G9E^vMcD&dA/yQA4S&ֿEbLil!>aDƋΪ~7A8n&]|vYoᡱ
Kyi׫w¡\~9$66Qnf>q,o,ӹI	散
I{.C>HnY-Qg̰tzfainvalid literal/length codeinvalid distance codeinvalid distance too far back`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	`Psp0	
` 	@	X	;x8	h(	H	T+t4	
d$	D	\	S|<	l,	L	R#r2	b"	B	Z	Cz:	j*	
J	V@3v6	f&	F		^	c~>	n.	N	`Qq1	
a!	A	Y	;y9	i)		I	U+u5	
e%	E	]	S}=	m-	
M	S#s3	c#	C	[	C{;	k+	K	W@3w7	g'	G		_	c?	o/	O	A@! 	@a`10
@	

incorrect length checkincorrect data checkinvalid distances setinvalid literal/lengths setinvalid bit length repeatinvalid code lengths settoo many length or distance symbolsinvalid stored block lengthsinvalid block typeheader crc mismatchunknown header flags setincorrect header checkinvalid window sizeunknown compression method inflate 1.2.3 Copyright 1995-2005 Mark Adler 	

#+3;CScs	
!1Aa 0@`@@incompatible versionbuffer errorinsufficient memorydata errorstream errorfile errorstream endneed dictionaryhB\B$UBPB@B4B BBB$UBfFK
I*TK
ITTK
IO :i+00SBi+00@_dP/N  !:i+00'":i+00
E%6NKKº}`fUܭHb0RF#/xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF΋!	Hx5i+.b`ODV	AH
FM^2mFT
d_N"
(2W]/4*&{-zeG'{-ph}OUBlOU3(9O> G e+.bchOU4^;ݧB}/NKfNr@"=3H$Oڠ'my4[J1B&M[OrG:ᠷqEJ ǬMWs5i+.bs5i+.bs5i+.bw~s5i+.b%e{HqC,㐲RO$[Dt.|I)sO>+dWnO@;>V;>V
Wt חb@J7<}iFϦODa'wj5Ob0wDObAGQ`{FL!mv`[c'wj5Obd'wj5Ob6J[CAVgqe'wj5Ob5i!Lz)zR88`[|^1/`[@L\J7@呰 חbu`ެ@`ެ.PRO—-T'tE`ެA`tpZdl?<W4plTI?rPB,ɨ=O${aPo0p,oiyŜ?Oɝa4Oص,OꙠς`RWpO6OyѦjc(=O0%G`묡51Mlg~6JNfs3K@~Oq!2)wKL+2V4K@~OqT'B6Q:.7V`ƆEz5K@~OqiI~+.ͩpO]_eOkm'WFAOлP0P0P0M]`gI6FOEг]K$^5N$̈&HS3M17i;'$9Y:Oh7%9Y:Oh7&9Y:Oh7'9Y:Oh7ի|I˃(9Y:Oh7!FsGF{H@FS2IEt$#CȫR
e.{ JOe/P($IZ^9$\E9O奄`OO\;x8WFTpj@wiKw^ևA)!\_[C+dWnO4DLe+.bSmb`ߌ #Or'>O.jxO^QmOd4'>Or3߷;`[MOKLb`wG:J'i>VMYFDAt;&OF}Ҩ\I;%S|
*E
yЎf|txMNI{@>KJ\FЗ4mc-NvEc7VfCNItwׄ8A!ӱJ'8EK}4@VqC(DW@XzvF@S>LNdL֬+o.Eцݷ"JL
:̿,LB)隇A }jL^6CTw]+.DJQS[bHNAFPCU	.4zl'K@-tК#FlHiawhM0Y3S!AbostA^?UX2NfHyu	5ꥂG)]/qNnN9jI=W.I|Kg
4cH~%]bM
I]7BWGCQl2$HܨEye64ۅ>eL:er='oOU{p OsCů$53QB`ϝ]v+qAO;ل.CZ0YcwN]ND.Q1RWHΨ}'CBg(#l^"`G3qs03NvFZ9\;û@Z|KJ$M>MEQ wmjKDWw? ec
E
kjO}c^NIe2mG)fpNr-O&oO}N8úGˢ)qKmHB" C[E|ti!OL'`gp+J=$?xԒhKGM]k>+$%|QOz)(BqF[͟WÅm]rLwx,4Ku@+׉#G``WG 35A	AlG؂تI`FtQ<[MEĀd_NM&uf4L3lEZIC~"@0(9A8L"k1%B	T
#F@FDF[Fʙ^AiXשFh
Mm8gh
z0Gd<O8mxO4yO"FFFMm8gh
0F1F2F3F%F)F*F0:s*Dw=IFy.Y+F&FEFGFHF:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/O:/ۆ/Oǝv\Wސy(_FFFFFFU
8r+C+n44FâRX0eu{ڮP9Vu{0ne0E
Kvne
yOܦϫ|xOjIOQnO09$-1.E^*onePone |~|?ne?PE^#1$-?W2$-?W2$-pw~?neg@ne˳j@ne˳j@ne?W2$-~{S^BEy|KDphKΔӳOհrIOxhO{lhO\`OOrOh7y)
Oh7BTyI6E9A!8ҏFs%E~2]rgO!B>9}Nr*GݓkFN]ͷghhϓgAc*^Z%Ȕ2AeqKW';?B@
J$SQ`Ɔ(œO>1s-O(hHjxOiQD(ߥl+ rˆLmCBUa{Ӱ~C.`1y/DĊYF;3bpc(Jg
Дէ{E]E)ПS-oEH?syYz(XGA'qQUAJ
sY!WOZ{*lg(M2(TfC'>|a. 	O;O.K[K8H]҇26 -&{-r:
%wCjW'tVamy!@iaWBVm`ɠI-`:Bn5OCښL%2J4{[kYs=BMQ!B\[/B{NsASÖ.̆I#t9JDf?kјH"tŻ-Gs?zZAe!`[ǽ6NXX$KiiőԞ(LqmjKH(.~,-Y@o3\.QCpg{L\l%IT߁KIs<_z\
LKo(t;sM|@)^vJYӞ~+IzÊChsxDpWJ?,CP0DOAoZ\q"tDk׾TLrTIkE
a`NNe76_I|kHrYM>s:
.jxOˡd:aDX7iii9P5}+EutX(T6QB~ۜC]_#ͼ_Ld=xr|խhG2`?uIp4Bf6חKt3
SNwL1"(iv@	YGح+ObC4`[ԄLr?RJ{,AsEOWL"O7v8yOhKKt&1Zs~:6B}Ftr⋪GMv2̤pDʹfD.b[GvtH;
zr\GڙYkH?x9J4uY&HxHϣ'GVBeUNOyדسDg,ݠeL3"5/QqCAwSk5X;-3B{_41lxƱLb
VBPoz5zD #D@Fgm[M/BT|\?@zpDF[0	49Z
I}AaB}KX䌠%D|DZ#&oIQd5CvSdn0@DH&'E4VwҁnB*O&-bfMlV!jt€I$[a#FVODJ

hFXapf_:qJ?򥸱PpZdFK6eJ7`, :i+00Fh3MnMܙS{5)xKt	O3CKsw`$D&l;0MHֿRUBu(dT&arrCuƋ.|uU:WPHw[ێ	Z܊M`* !sG3^F0MJSkyZ
8y
M3,/KqI\M;TQI![Y
,!PCsg?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~_.,._;=C=;EncodePointerKERNEL32.DLLDecodePointerFlsFreeFlsSetValueFlsGetValueFlsAllocruntime error 
TLOSS error
SING error
DOMAIN error
R6034
An application has made an attempt to load the C runtime library incorrectly.
Please contact the application's support team for more information.
R6033
- Attempt to use MSIL code from this assembly during native code initialization
This indicates a bug in your application. It is most likely the result of calling an MSIL-compiled (/clr) function from a native constructor or from DllMain.
R6032
- not enough space for locale information
R6031
- Attempt to initialize the CRT more than once.
This indicates a bug in your application.
R6030
- CRT not initialized
R6028
- unable to initialize heap
R6027
- not enough space for lowio initialization
R6026
- not enough space for stdio initialization
R6025
- pure virtual function call
R6024
- not enough space for _onexit/atexit table
R6019
- unable to open console device
R6018
- unexpected heap error
R6017
- unexpected multithread lock error
R6016
- not enough space for thread data

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.
R6009
- not enough space for environment
R6008
- not enough space for arguments
R6002
- floating point support not loaded
Microsoft Visual C++ Runtime Library

...Runtime Error!

Program: (null)(null)EEE50P( 8PX700WP  `h````xpxxxxccsUTF-8UTF-16LEUNICODESystemFunction036ADVAPI32.DLL         (((((                  H          h((((                  H                                 H	

 !"#$%&'()*+,-./0123456789:;<=>?@abcdefghijklmnopqrstuvwxyz[\]^_`abcdefghijklmnopqrstuvwxyz{|}~	

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ABCDEFGHIJKLMNOPQRSTUVWXYZ{|}~united-statesunited-kingdomtrinidad & tobagosouth-koreasouth-africasouth koreasouth africaslovakpuerto-ricopr-chinapr chinanznew-zealandhong-konghollandgreat britainenglandczechchinabritainamericausausukswissswedish-finlandspanish-venezuelaspanish-uruguayspanish-puerto ricospanish-peruspanish-paraguayspanish-panamaspanish-nicaraguaspanish-modernspanish-mexicanspanish-hondurasspanish-guatemalaspanish-el salvadorspanish-ecuadorspanish-dominican republicspanish-costa ricaspanish-colombiaspanish-chilespanish-boliviaspanish-argentinaportuguese-braziliannorwegian-nynorsknorwegian-bokmalnorwegianitalian-swissirish-englishgerman-swissgerman-luxembourggerman-lichtensteingerman-austrianfrench-swissfrench-luxembourgfrench-canadianfrench-belgianenglish-usaenglish-usenglish-ukenglish-trinidad y tobagoenglish-south africaenglish-nzenglish-jamaicaenglish-ireenglish-caribbeanenglish-canenglish-belizeenglish-ausenglish-americandutch-belgianchinese-traditionalchinese-singaporechinese-simplifiedchinese-hongkongchinesechichhcanadianbelgianaustralianamerican-englishamerican englishamericanBENUBENUBENUBENABNLBBENCBZHH|BZHItBCHS`BZHHLBCHS8BZHI$BCHTBNLBBENUBENABENLBENCBENBBENIBENJBENZBENShBENT\BENGPBENUDBENU4BFRB$BFRCBFRLBFRSBDEABDECBDELBDESBENIBITSBNORxBNORdBNONLBPTB8BESS(BESBBESLBESOBESCBESDBESFBESEBESGBESHxBESMhBESNTBESIDBESA0BESZ BESRBESUBESYBESVBSVFBDESBENGBENUBENUBUSABGBRBCHNBCZEBGBRBGBRBNLDxBHKGlBNZLhBNZL\BCHNPBCHNDBPRIBCB2DBDB(PLXP0Rp4PP2(RDtRzfTN>2&\2BVfv6|lVD.
v^Dv`TB4$~6N`r0F`l(6N^nz"th>~p^LZ.d>PPropertySheetACreatePropertySheetPageACOMCTL32.dllSetLastErrormCreateDirectoryAGetFileAttributesAMapViewOfFilezCreateFileMappingADCloseHandleSetFileTimeDosDateTimeToFileTimeGetLastErroryCreateFileAKUnmapViewOfFilelstrlenAMultiByteToWideChar"GetProcAddressLoadLibraryADeleteFileAnReadFileSetFilePointerGetFileSizeMFreeLibrarySetStdHandle>GetStdHandleLocalFreeHFormatMessageA\GetTempFileNameA^GetTempPathAGetModuleHandleAzGetVersionExAResumeThreadSetPriorityClassGetCurrentProcessGetCurrentThreadSetThreadPriorityCreateProcessAGetModuleFileNameARemoveDirectoryAGetPrivateProfileIntAGetPrivateProfileStringAGetModuleFileNameWKERNEL32.dllMessageBoxA$GetFocuswsprintfAvSetDlgItemTextA^SendMessageALReleaseDCGetDCDispatchMessageATranslateMessagePeekMessageAEndPaintoGetSystemMetricsBeginPaintDefWindowProcAUpdateWindowShowWindowgCreateWindowExA3RegisterClassALoadCursorAMoveWindowGetWindowRectPostMessageAUGetParentYSendDlgItemMessageAGetDlgItempSetCursorUSER32.dll4CreateDIBitmapDeleteObjectSetTextColorTextOutAfSetBkMode^SelectObject:CreateFontARCreateSolidBrushGDI32.dllfRegQueryValueA*RegCloseKeygRegQueryValueExAHRegEnumKeyExAZRegOpenKeyExAwRegSetValueExA2RegCreateKeyExA7RegDeleteKeyAARegDeleteValueAADVAPI32.dllShellExecuteASHELL32.dllkCoUninitializeCoCreateInstance=CoInitializeole32.dllSGetSystemTimeAsFileTimeHeapFreeHeapAllocFileTimeToSystemTimeFileTimeToLocalFileTimeGetFileInformationByHandleCPeekNamedPipeGetFileTypeEnterCriticalSectionLeaveCriticalSectionlGetTimeFormatAGetDateFormatAHeapReAllocGetModuleHandleW+SleepExitProcesspGetCommandLineA<GetStartupInfoA7TerminateProcessHUnhandledExceptionFilterSetUnhandledExceptionFilterIsDebuggerPresentWideCharToMultiByteoGetTimeZoneInformation\GetCPInfoInterlockedIncrementInterlockedDecrementSGetACPGetOEMCPIsValidCodePage>TlsGetValue<TlsAlloc?TlsSetValue=TlsFreeGetCurrentThreadIdHeapCreateHeapDestroyaVirtualFreeDeleteCriticalSectionFatalAppExitA^VirtualAllocWriteFileSetEnvironmentVariableASetEnvironmentVariableWSetHandleCountGetConsoleCPGetConsoleModeRtlUnwindSetConsoleCtrlHandlerInterlockedExchangeInitializeCriticalSectionAndSpinCountKFreeEnvironmentStringsAGetEnvironmentStringsLFreeEnvironmentStringsWGetEnvironmentStringsWYQueryPerformanceCounterjGetTickCountGetCurrentProcessIdLCMapStringALCMapStringW@GetStringTypeACGetStringTypeWrGetUserDefaultLCIDGetLocaleInfoAEnumSystemLocalesAIsValidLocaleBFlushFileBuffersWriteConsoleAGetConsoleOutputCPWriteConsoleWHeapSizeGetLocaleInfoWVCompareStringWSCompareStringASetEndOfFile&GetProcessHeap(UB$UBUB$UBUB$UBUBUBTB$UB(UBTBUBTBUB$UBUBUBTB$UBSoftware\Microsoft\Windows\CurrentVersion\UninstallTBTBTBTBtTB\TBLTB4TB$TBTBTB1@SB@SB@SBu@@SB@@SB@@Software\Microsoft\Windows\CurrentVersion\UninstallN@D*C*CBBBBBBBBBBBtBlB`B\BXBTBPBLBHBDB@B
  
    
      
        
      
    
  
PAPADDINGXXPADDING././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/config.py0000644000175100001730000001145714467657412021705 0ustar00runnerdocker"""distutils.pypirc

Provides the PyPIRCCommand class, the base class for the command classes
that uses .pypirc in the distutils.command package.
"""
import os
from configparser import RawConfigParser

from .cmd import Command

DEFAULT_PYPIRC = """\
[distutils]
index-servers =
    pypi

[pypi]
username:%s
password:%s
"""


class PyPIRCCommand(Command):
    """Base command that knows how to handle the .pypirc file"""

    DEFAULT_REPOSITORY = 'https://upload.pypi.org/legacy/'
    DEFAULT_REALM = 'pypi'
    repository = None
    realm = None

    user_options = [
        ('repository=', 'r', "url of repository [default: %s]" % DEFAULT_REPOSITORY),
        ('show-response', None, 'display full response text from server'),
    ]

    boolean_options = ['show-response']

    def _get_rc_file(self):
        """Returns rc file path."""
        return os.path.join(os.path.expanduser('~'), '.pypirc')

    def _store_pypirc(self, username, password):
        """Creates a default .pypirc file."""
        rc = self._get_rc_file()
        with os.fdopen(os.open(rc, os.O_CREAT | os.O_WRONLY, 0o600), 'w') as f:
            f.write(DEFAULT_PYPIRC % (username, password))

    def _read_pypirc(self):  # noqa: C901
        """Reads the .pypirc file."""
        rc = self._get_rc_file()
        if os.path.exists(rc):
            self.announce('Using PyPI login from %s' % rc)
            repository = self.repository or self.DEFAULT_REPOSITORY

            config = RawConfigParser()
            config.read(rc)
            sections = config.sections()
            if 'distutils' in sections:
                # let's get the list of servers
                index_servers = config.get('distutils', 'index-servers')
                _servers = [
                    server.strip()
                    for server in index_servers.split('\n')
                    if server.strip() != ''
                ]
                if _servers == []:
                    # nothing set, let's try to get the default pypi
                    if 'pypi' in sections:
                        _servers = ['pypi']
                    else:
                        # the file is not properly defined, returning
                        # an empty dict
                        return {}
                for server in _servers:
                    current = {'server': server}
                    current['username'] = config.get(server, 'username')

                    # optional params
                    for key, default in (
                        ('repository', self.DEFAULT_REPOSITORY),
                        ('realm', self.DEFAULT_REALM),
                        ('password', None),
                    ):
                        if config.has_option(server, key):
                            current[key] = config.get(server, key)
                        else:
                            current[key] = default

                    # work around people having "repository" for the "pypi"
                    # section of their config set to the HTTP (rather than
                    # HTTPS) URL
                    if server == 'pypi' and repository in (
                        self.DEFAULT_REPOSITORY,
                        'pypi',
                    ):
                        current['repository'] = self.DEFAULT_REPOSITORY
                        return current

                    if (
                        current['server'] == repository
                        or current['repository'] == repository
                    ):
                        return current
            elif 'server-login' in sections:
                # old format
                server = 'server-login'
                if config.has_option(server, 'repository'):
                    repository = config.get(server, 'repository')
                else:
                    repository = self.DEFAULT_REPOSITORY
                return {
                    'username': config.get(server, 'username'),
                    'password': config.get(server, 'password'),
                    'repository': repository,
                    'server': server,
                    'realm': self.DEFAULT_REALM,
                }

        return {}

    def _read_pypi_response(self, response):
        """Read and decode a PyPI HTTP response."""
        import cgi

        content_type = response.getheader('content-type', 'text/plain')
        encoding = cgi.parse_header(content_type)[1].get('charset', 'ascii')
        return response.read().decode(encoding)

    def initialize_options(self):
        """Initialize options."""
        self.repository = None
        self.realm = None
        self.show_response = 0

    def finalize_options(self):
        """Finalizes options."""
        if self.repository is None:
            self.repository = self.DEFAULT_REPOSITORY
        if self.realm is None:
            self.realm = self.DEFAULT_REALM
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/core.py0000644000175100001730000002226514467657412021367 0ustar00runnerdocker"""distutils.core

The only module that needs to be imported to use the Distutils; provides
the 'setup' function (which is to be called from the setup script).  Also
indirectly provides the Distribution and Command classes, although they are
really defined in distutils.dist and distutils.cmd.
"""

import os
import sys
import tokenize

from .debug import DEBUG
from .errors import (
    DistutilsSetupError,
    DistutilsError,
    CCompilerError,
    DistutilsArgError,
)

# Mainly import these so setup scripts can "from distutils.core import" them.
from .dist import Distribution
from .cmd import Command
from .config import PyPIRCCommand
from .extension import Extension


__all__ = ['Distribution', 'Command', 'PyPIRCCommand', 'Extension', 'setup']

# This is a barebones help message generated displayed when the user
# runs the setup script with no arguments at all.  More useful help
# is generated with various --help options: global help, list commands,
# and per-command help.
USAGE = """\
usage: %(script)s [global_opts] cmd1 [cmd1_opts] [cmd2 [cmd2_opts] ...]
   or: %(script)s --help [cmd1 cmd2 ...]
   or: %(script)s --help-commands
   or: %(script)s cmd --help
"""


def gen_usage(script_name):
    script = os.path.basename(script_name)
    return USAGE % locals()


# Some mild magic to control the behaviour of 'setup()' from 'run_setup()'.
_setup_stop_after = None
_setup_distribution = None

# Legal keyword arguments for the setup() function
setup_keywords = (
    'distclass',
    'script_name',
    'script_args',
    'options',
    'name',
    'version',
    'author',
    'author_email',
    'maintainer',
    'maintainer_email',
    'url',
    'license',
    'description',
    'long_description',
    'keywords',
    'platforms',
    'classifiers',
    'download_url',
    'requires',
    'provides',
    'obsoletes',
)

# Legal keyword arguments for the Extension constructor
extension_keywords = (
    'name',
    'sources',
    'include_dirs',
    'define_macros',
    'undef_macros',
    'library_dirs',
    'libraries',
    'runtime_library_dirs',
    'extra_objects',
    'extra_compile_args',
    'extra_link_args',
    'swig_opts',
    'export_symbols',
    'depends',
    'language',
)


def setup(**attrs):  # noqa: C901
    """The gateway to the Distutils: do everything your setup script needs
    to do, in a highly flexible and user-driven way.  Briefly: create a
    Distribution instance; find and parse config files; parse the command
    line; run each Distutils command found there, customized by the options
    supplied to 'setup()' (as keyword arguments), in config files, and on
    the command line.

    The Distribution instance might be an instance of a class supplied via
    the 'distclass' keyword argument to 'setup'; if no such class is
    supplied, then the Distribution class (in dist.py) is instantiated.
    All other arguments to 'setup' (except for 'cmdclass') are used to set
    attributes of the Distribution instance.

    The 'cmdclass' argument, if supplied, is a dictionary mapping command
    names to command classes.  Each command encountered on the command line
    will be turned into a command class, which is in turn instantiated; any
    class found in 'cmdclass' is used in place of the default, which is
    (for command 'foo_bar') class 'foo_bar' in module
    'distutils.command.foo_bar'.  The command class must provide a
    'user_options' attribute which is a list of option specifiers for
    'distutils.fancy_getopt'.  Any command-line options between the current
    and the next command are used to set attributes of the current command
    object.

    When the entire command-line has been successfully parsed, calls the
    'run()' method on each command object in turn.  This method will be
    driven entirely by the Distribution object (which each command object
    has a reference to, thanks to its constructor), and the
    command-specific options that became attributes of each command
    object.
    """

    global _setup_stop_after, _setup_distribution

    # Determine the distribution class -- either caller-supplied or
    # our Distribution (see below).
    klass = attrs.get('distclass')
    if klass:
        attrs.pop('distclass')
    else:
        klass = Distribution

    if 'script_name' not in attrs:
        attrs['script_name'] = os.path.basename(sys.argv[0])
    if 'script_args' not in attrs:
        attrs['script_args'] = sys.argv[1:]

    # Create the Distribution instance, using the remaining arguments
    # (ie. everything except distclass) to initialize it
    try:
        _setup_distribution = dist = klass(attrs)
    except DistutilsSetupError as msg:
        if 'name' not in attrs:
            raise SystemExit("error in setup command: %s" % msg)
        else:
            raise SystemExit("error in {} setup command: {}".format(attrs['name'], msg))

    if _setup_stop_after == "init":
        return dist

    # Find and parse the config file(s): they will override options from
    # the setup script, but be overridden by the command line.
    dist.parse_config_files()

    if DEBUG:
        print("options (after parsing config files):")
        dist.dump_option_dicts()

    if _setup_stop_after == "config":
        return dist

    # Parse the command line and override config files; any
    # command-line errors are the end user's fault, so turn them into
    # SystemExit to suppress tracebacks.
    try:
        ok = dist.parse_command_line()
    except DistutilsArgError as msg:
        raise SystemExit(gen_usage(dist.script_name) + "\nerror: %s" % msg)

    if DEBUG:
        print("options (after parsing command line):")
        dist.dump_option_dicts()

    if _setup_stop_after == "commandline":
        return dist

    # And finally, run all the commands found on the command line.
    if ok:
        return run_commands(dist)

    return dist


# setup ()


def run_commands(dist):
    """Given a Distribution object run all the commands,
    raising ``SystemExit`` errors in the case of failure.

    This function assumes that either ``sys.argv`` or ``dist.script_args``
    is already set accordingly.
    """
    try:
        dist.run_commands()
    except KeyboardInterrupt:
        raise SystemExit("interrupted")
    except OSError as exc:
        if DEBUG:
            sys.stderr.write("error: {}\n".format(exc))
            raise
        else:
            raise SystemExit("error: {}".format(exc))

    except (DistutilsError, CCompilerError) as msg:
        if DEBUG:
            raise
        else:
            raise SystemExit("error: " + str(msg))

    return dist


def run_setup(script_name, script_args=None, stop_after="run"):
    """Run a setup script in a somewhat controlled environment, and
    return the Distribution instance that drives things.  This is useful
    if you need to find out the distribution meta-data (passed as
    keyword args from 'script' to 'setup()', or the contents of the
    config files or command-line.

    'script_name' is a file that will be read and run with 'exec()';
    'sys.argv[0]' will be replaced with 'script' for the duration of the
    call.  'script_args' is a list of strings; if supplied,
    'sys.argv[1:]' will be replaced by 'script_args' for the duration of
    the call.

    'stop_after' tells 'setup()' when to stop processing; possible
    values:
      init
        stop after the Distribution instance has been created and
        populated with the keyword arguments to 'setup()'
      config
        stop after config files have been parsed (and their data
        stored in the Distribution instance)
      commandline
        stop after the command-line ('sys.argv[1:]' or 'script_args')
        have been parsed (and the data stored in the Distribution)
      run [default]
        stop after all commands have been run (the same as if 'setup()'
        had been called in the usual way

    Returns the Distribution instance, which provides all information
    used to drive the Distutils.
    """
    if stop_after not in ('init', 'config', 'commandline', 'run'):
        raise ValueError("invalid value for 'stop_after': {!r}".format(stop_after))

    global _setup_stop_after, _setup_distribution
    _setup_stop_after = stop_after

    save_argv = sys.argv.copy()
    g = {'__file__': script_name, '__name__': '__main__'}
    try:
        try:
            sys.argv[0] = script_name
            if script_args is not None:
                sys.argv[1:] = script_args
            # tokenize.open supports automatic encoding detection
            with tokenize.open(script_name) as f:
                code = f.read().replace(r'\r\n', r'\n')
                exec(code, g)
        finally:
            sys.argv = save_argv
            _setup_stop_after = None
    except SystemExit:
        # Hmm, should we do something if exiting with a non-zero code
        # (ie. error)?
        pass

    if _setup_distribution is None:
        raise RuntimeError(
            (
                "'distutils.core.setup()' was never called -- "
                "perhaps '%s' is not a Distutils setup script?"
            )
            % script_name
        )

    # I wonder if the setup script's namespace -- g and l -- would be of
    # any interest to callers?
    # print "_setup_distribution:", _setup_distribution
    return _setup_distribution


# run_setup ()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/cygwinccompiler.py0000644000175100001730000002722414467657412023635 0ustar00runnerdocker"""distutils.cygwinccompiler

Provides the CygwinCCompiler class, a subclass of UnixCCompiler that
handles the Cygwin port of the GNU C compiler to Windows.  It also contains
the Mingw32CCompiler class which handles the mingw32 port of GCC (same as
cygwin in no-cygwin mode).
"""

import os
import re
import sys
import copy
import shlex
import warnings
from subprocess import check_output

from .unixccompiler import UnixCCompiler
from .file_util import write_file
from .errors import (
    DistutilsExecError,
    DistutilsPlatformError,
    CCompilerError,
    CompileError,
)
from .version import LooseVersion, suppress_known_deprecation
from ._collections import RangeMap


_msvcr_lookup = RangeMap.left(
    {
        # MSVC 7.0
        1300: ['msvcr70'],
        # MSVC 7.1
        1310: ['msvcr71'],
        # VS2005 / MSVC 8.0
        1400: ['msvcr80'],
        # VS2008 / MSVC 9.0
        1500: ['msvcr90'],
        # VS2010 / MSVC 10.0
        1600: ['msvcr100'],
        # VS2012 / MSVC 11.0
        1700: ['msvcr110'],
        # VS2013 / MSVC 12.0
        1800: ['msvcr120'],
        # VS2015 / MSVC 14.0
        1900: ['vcruntime140'],
        2000: RangeMap.undefined_value,
    },
)


def get_msvcr():
    """Include the appropriate MSVC runtime library if Python was built
    with MSVC 7.0 or later.
    """
    match = re.search(r'MSC v\.(\d{4})', sys.version)
    try:
        msc_ver = int(match.group(1))
    except AttributeError:
        return
    try:
        return _msvcr_lookup[msc_ver]
    except KeyError:
        raise ValueError("Unknown MS Compiler version %s " % msc_ver)


_runtime_library_dirs_msg = (
    "Unable to set runtime library search path on Windows, "
    "usually indicated by `runtime_library_dirs` parameter to Extension"
)


class CygwinCCompiler(UnixCCompiler):
    """Handles the Cygwin port of the GNU C compiler to Windows."""

    compiler_type = 'cygwin'
    obj_extension = ".o"
    static_lib_extension = ".a"
    shared_lib_extension = ".dll.a"
    dylib_lib_extension = ".dll"
    static_lib_format = "lib%s%s"
    shared_lib_format = "lib%s%s"
    dylib_lib_format = "cyg%s%s"
    exe_extension = ".exe"

    def __init__(self, verbose=0, dry_run=0, force=0):
        super().__init__(verbose, dry_run, force)

        status, details = check_config_h()
        self.debug_print(
            "Python's GCC status: {} (details: {})".format(status, details)
        )
        if status is not CONFIG_H_OK:
            self.warn(
                "Python's pyconfig.h doesn't seem to support your compiler. "
                "Reason: %s. "
                "Compiling may fail because of undefined preprocessor macros." % details
            )

        self.cc = os.environ.get('CC', 'gcc')
        self.cxx = os.environ.get('CXX', 'g++')

        self.linker_dll = self.cc
        shared_option = "-shared"

        self.set_executables(
            compiler='%s -mcygwin -O -Wall' % self.cc,
            compiler_so='%s -mcygwin -mdll -O -Wall' % self.cc,
            compiler_cxx='%s -mcygwin -O -Wall' % self.cxx,
            linker_exe='%s -mcygwin' % self.cc,
            linker_so=('{} -mcygwin {}'.format(self.linker_dll, shared_option)),
        )

        # Include the appropriate MSVC runtime library if Python was built
        # with MSVC 7.0 or later.
        self.dll_libraries = get_msvcr()

    @property
    def gcc_version(self):
        # Older numpy depended on this existing to check for ancient
        # gcc versions. This doesn't make much sense with clang etc so
        # just hardcode to something recent.
        # https://github.com/numpy/numpy/pull/20333
        warnings.warn(
            "gcc_version attribute of CygwinCCompiler is deprecated. "
            "Instead of returning actual gcc version a fixed value 11.2.0 is returned.",
            DeprecationWarning,
            stacklevel=2,
        )
        with suppress_known_deprecation():
            return LooseVersion("11.2.0")

    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        """Compiles the source by spawning GCC and windres if needed."""
        if ext in ('.rc', '.res'):
            # gcc needs '.res' and '.rc' compiled to object files !!!
            try:
                self.spawn(["windres", "-i", src, "-o", obj])
            except DistutilsExecError as msg:
                raise CompileError(msg)
        else:  # for other files use the C-compiler
            try:
                self.spawn(
                    self.compiler_so + cc_args + [src, '-o', obj] + extra_postargs
                )
            except DistutilsExecError as msg:
                raise CompileError(msg)

    def link(
        self,
        target_desc,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        """Link the objects."""
        # use separate copies, so we can modify the lists
        extra_preargs = copy.copy(extra_preargs or [])
        libraries = copy.copy(libraries or [])
        objects = copy.copy(objects or [])

        if runtime_library_dirs:
            self.warn(_runtime_library_dirs_msg)

        # Additional libraries
        libraries.extend(self.dll_libraries)

        # handle export symbols by creating a def-file
        # with executables this only works with gcc/ld as linker
        if (export_symbols is not None) and (
            target_desc != self.EXECUTABLE or self.linker_dll == "gcc"
        ):
            # (The linker doesn't do anything if output is up-to-date.
            # So it would probably better to check if we really need this,
            # but for this we had to insert some unchanged parts of
            # UnixCCompiler, and this is not what we want.)

            # we want to put some files in the same directory as the
            # object files are, build_temp doesn't help much
            # where are the object files
            temp_dir = os.path.dirname(objects[0])
            # name of dll to give the helper files the same base name
            (dll_name, dll_extension) = os.path.splitext(
                os.path.basename(output_filename)
            )

            # generate the filenames for these files
            def_file = os.path.join(temp_dir, dll_name + ".def")

            # Generate .def file
            contents = ["LIBRARY %s" % os.path.basename(output_filename), "EXPORTS"]
            for sym in export_symbols:
                contents.append(sym)
            self.execute(write_file, (def_file, contents), "writing %s" % def_file)

            # next add options for def-file

            # for gcc/ld the def-file is specified as any object files
            objects.append(def_file)

        # end: if ((export_symbols is not None) and
        #        (target_desc != self.EXECUTABLE or self.linker_dll == "gcc")):

        # who wants symbols and a many times larger output file
        # should explicitly switch the debug mode on
        # otherwise we let ld strip the output file
        # (On my machine: 10KiB < stripped_file < ??100KiB
        #   unstripped_file = stripped_file + XXX KiB
        #  ( XXX=254 for a typical python extension))
        if not debug:
            extra_preargs.append("-s")

        UnixCCompiler.link(
            self,
            target_desc,
            objects,
            output_filename,
            output_dir,
            libraries,
            library_dirs,
            runtime_library_dirs,
            None,  # export_symbols, we do this in our def-file
            debug,
            extra_preargs,
            extra_postargs,
            build_temp,
            target_lang,
        )

    def runtime_library_dir_option(self, dir):
        # cygwin doesn't support rpath. While in theory we could error
        # out like MSVC does, code might expect it to work like on Unix, so
        # just warn and hope for the best.
        self.warn(_runtime_library_dirs_msg)
        return []

    # -- Miscellaneous methods -----------------------------------------

    def _make_out_path(self, output_dir, strip_dir, src_name):
        # use normcase to make sure '.rc' is really '.rc' and not '.RC'
        norm_src_name = os.path.normcase(src_name)
        return super()._make_out_path(output_dir, strip_dir, norm_src_name)

    @property
    def out_extensions(self):
        """
        Add support for rc and res files.
        """
        return {
            **super().out_extensions,
            **{ext: ext + self.obj_extension for ext in ('.res', '.rc')},
        }


# the same as cygwin plus some additional parameters
class Mingw32CCompiler(CygwinCCompiler):
    """Handles the Mingw32 port of the GNU C compiler to Windows."""

    compiler_type = 'mingw32'

    def __init__(self, verbose=0, dry_run=0, force=0):
        super().__init__(verbose, dry_run, force)

        shared_option = "-shared"

        if is_cygwincc(self.cc):
            raise CCompilerError('Cygwin gcc cannot be used with --compiler=mingw32')

        self.set_executables(
            compiler='%s -O -Wall' % self.cc,
            compiler_so='%s -mdll -O -Wall' % self.cc,
            compiler_cxx='%s -O -Wall' % self.cxx,
            linker_exe='%s' % self.cc,
            linker_so='{} {}'.format(self.linker_dll, shared_option),
        )

    def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(_runtime_library_dirs_msg)


# Because these compilers aren't configured in Python's pyconfig.h file by
# default, we should at least warn the user if he is using an unmodified
# version.

CONFIG_H_OK = "ok"
CONFIG_H_NOTOK = "not ok"
CONFIG_H_UNCERTAIN = "uncertain"


def check_config_h():
    """Check if the current Python installation appears amenable to building
    extensions with GCC.

    Returns a tuple (status, details), where 'status' is one of the following
    constants:

    - CONFIG_H_OK: all is well, go ahead and compile
    - CONFIG_H_NOTOK: doesn't look good
    - CONFIG_H_UNCERTAIN: not sure -- unable to read pyconfig.h

    'details' is a human-readable string explaining the situation.

    Note there are two ways to conclude "OK": either 'sys.version' contains
    the string "GCC" (implying that this Python was built with GCC), or the
    installed "pyconfig.h" contains the string "__GNUC__".
    """

    # XXX since this function also checks sys.version, it's not strictly a
    # "pyconfig.h" check -- should probably be renamed...

    from distutils import sysconfig

    # if sys.version contains GCC then python was compiled with GCC, and the
    # pyconfig.h file should be OK
    if "GCC" in sys.version:
        return CONFIG_H_OK, "sys.version mentions 'GCC'"

    # Clang would also work
    if "Clang" in sys.version:
        return CONFIG_H_OK, "sys.version mentions 'Clang'"

    # let's see if __GNUC__ is mentioned in python.h
    fn = sysconfig.get_config_h_filename()
    try:
        config_h = open(fn)
        try:
            if "__GNUC__" in config_h.read():
                return CONFIG_H_OK, "'%s' mentions '__GNUC__'" % fn
            else:
                return CONFIG_H_NOTOK, "'%s' does not mention '__GNUC__'" % fn
        finally:
            config_h.close()
    except OSError as exc:
        return (CONFIG_H_UNCERTAIN, "couldn't read '{}': {}".format(fn, exc.strerror))


def is_cygwincc(cc):
    '''Try to determine if the compiler that would be used is from cygwin.'''
    out_string = check_output(shlex.split(cc) + ['-dumpmachine'])
    return out_string.strip().endswith(b'cygwin')


get_versions = None
"""
A stand-in for the previous get_versions() function to prevent failures
when monkeypatched. See pypa/setuptools#2969.
"""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/debug.py0000644000175100001730000000021314467657412021512 0ustar00runnerdockerimport os

# If DISTUTILS_DEBUG is anything other than the empty string, we run in
# debug mode.
DEBUG = os.environ.get('DISTUTILS_DEBUG')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/dep_util.py0000644000175100001730000000652614467657412022246 0ustar00runnerdocker"""distutils.dep_util

Utility functions for simple, timestamp-based dependency of files
and groups of files; also, function based entirely on such
timestamp dependency analysis."""

import os
from .errors import DistutilsFileError


def newer(source, target):
    """Return true if 'source' exists and is more recently modified than
    'target', or if 'source' exists and 'target' doesn't.  Return false if
    both exist and 'target' is the same age or younger than 'source'.
    Raise DistutilsFileError if 'source' does not exist.
    """
    if not os.path.exists(source):
        raise DistutilsFileError("file '%s' does not exist" % os.path.abspath(source))
    if not os.path.exists(target):
        return 1

    from stat import ST_MTIME

    mtime1 = os.stat(source)[ST_MTIME]
    mtime2 = os.stat(target)[ST_MTIME]

    return mtime1 > mtime2


# newer ()


def newer_pairwise(sources, targets):
    """Walk two filename lists in parallel, testing if each source is newer
    than its corresponding target.  Return a pair of lists (sources,
    targets) where source is newer than target, according to the semantics
    of 'newer()'.
    """
    if len(sources) != len(targets):
        raise ValueError("'sources' and 'targets' must be same length")

    # build a pair of lists (sources, targets) where  source is newer
    n_sources = []
    n_targets = []
    for i in range(len(sources)):
        if newer(sources[i], targets[i]):
            n_sources.append(sources[i])
            n_targets.append(targets[i])

    return (n_sources, n_targets)


# newer_pairwise ()


def newer_group(sources, target, missing='error'):
    """Return true if 'target' is out-of-date with respect to any file
    listed in 'sources'.  In other words, if 'target' exists and is newer
    than every file in 'sources', return false; otherwise return true.
    'missing' controls what we do when a source file is missing; the
    default ("error") is to blow up with an OSError from inside 'stat()';
    if it is "ignore", we silently drop any missing source files; if it is
    "newer", any missing source files make us assume that 'target' is
    out-of-date (this is handy in "dry-run" mode: it'll make you pretend to
    carry out commands that wouldn't work because inputs are missing, but
    that doesn't matter because you're not actually going to run the
    commands).
    """
    # If the target doesn't even exist, then it's definitely out-of-date.
    if not os.path.exists(target):
        return 1

    # Otherwise we have to find out the hard way: if *any* source file
    # is more recent than 'target', then 'target' is out-of-date and
    # we can immediately return true.  If we fall through to the end
    # of the loop, then 'target' is up-to-date and we return false.
    from stat import ST_MTIME

    target_mtime = os.stat(target)[ST_MTIME]
    for source in sources:
        if not os.path.exists(source):
            if missing == 'error':  # blow up when we stat() the file
                pass
            elif missing == 'ignore':  # missing source dropped from
                continue  # target's dependency list
            elif missing == 'newer':  # missing source means target is
                return 1  # out-of-date

        source_mtime = os.stat(source)[ST_MTIME]
        if source_mtime > target_mtime:
            return 1
    else:
        return 0


# newer_group ()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/dir_util.py0000644000175100001730000001761014467657412022250 0ustar00runnerdocker"""distutils.dir_util

Utility functions for manipulating directories and directory trees."""

import os
import errno
from .errors import DistutilsInternalError, DistutilsFileError
from ._log import log

# cache for by mkpath() -- in addition to cheapening redundant calls,
# eliminates redundant "creating /foo/bar/baz" messages in dry-run mode
_path_created = {}


def mkpath(name, mode=0o777, verbose=1, dry_run=0):  # noqa: C901
    """Create a directory and any missing ancestor directories.

    If the directory already exists (or if 'name' is the empty string, which
    means the current directory, which of course exists), then do nothing.
    Raise DistutilsFileError if unable to create some directory along the way
    (eg. some sub-path exists, but is a file rather than a directory).
    If 'verbose' is true, print a one-line summary of each mkdir to stdout.
    Return the list of directories actually created.

    os.makedirs is not used because:

    a) It's new to Python 1.5.2, and
    b) it blows up if the directory already exists (in which case it should
       silently succeed).
    """

    global _path_created

    # Detect a common bug -- name is None
    if not isinstance(name, str):
        raise DistutilsInternalError(
            "mkpath: 'name' must be a string (got {!r})".format(name)
        )

    # XXX what's the better way to handle verbosity? print as we create
    # each directory in the path (the current behaviour), or only announce
    # the creation of the whole path? (quite easy to do the latter since
    # we're not using a recursive algorithm)

    name = os.path.normpath(name)
    created_dirs = []
    if os.path.isdir(name) or name == '':
        return created_dirs
    if _path_created.get(os.path.abspath(name)):
        return created_dirs

    (head, tail) = os.path.split(name)
    tails = [tail]  # stack of lone dirs to create

    while head and tail and not os.path.isdir(head):
        (head, tail) = os.path.split(head)
        tails.insert(0, tail)  # push next higher dir onto stack

    # now 'head' contains the deepest directory that already exists
    # (that is, the child of 'head' in 'name' is the highest directory
    # that does *not* exist)
    for d in tails:
        # print "head = %s, d = %s: " % (head, d),
        head = os.path.join(head, d)
        abs_head = os.path.abspath(head)

        if _path_created.get(abs_head):
            continue

        if verbose >= 1:
            log.info("creating %s", head)

        if not dry_run:
            try:
                os.mkdir(head, mode)
            except OSError as exc:
                if not (exc.errno == errno.EEXIST and os.path.isdir(head)):
                    raise DistutilsFileError(
                        "could not create '{}': {}".format(head, exc.args[-1])
                    )
            created_dirs.append(head)

        _path_created[abs_head] = 1
    return created_dirs


def create_tree(base_dir, files, mode=0o777, verbose=1, dry_run=0):
    """Create all the empty directories under 'base_dir' needed to put 'files'
    there.

    'base_dir' is just the name of a directory which doesn't necessarily
    exist yet; 'files' is a list of filenames to be interpreted relative to
    'base_dir'.  'base_dir' + the directory portion of every file in 'files'
    will be created if it doesn't already exist.  'mode', 'verbose' and
    'dry_run' flags are as for 'mkpath()'.
    """
    # First get the list of directories to create
    need_dir = set()
    for file in files:
        need_dir.add(os.path.join(base_dir, os.path.dirname(file)))

    # Now create them
    for dir in sorted(need_dir):
        mkpath(dir, mode, verbose=verbose, dry_run=dry_run)


def copy_tree(  # noqa: C901
    src,
    dst,
    preserve_mode=1,
    preserve_times=1,
    preserve_symlinks=0,
    update=0,
    verbose=1,
    dry_run=0,
):
    """Copy an entire directory tree 'src' to a new location 'dst'.

    Both 'src' and 'dst' must be directory names.  If 'src' is not a
    directory, raise DistutilsFileError.  If 'dst' does not exist, it is
    created with 'mkpath()'.  The end result of the copy is that every
    file in 'src' is copied to 'dst', and directories under 'src' are
    recursively copied to 'dst'.  Return the list of files that were
    copied or might have been copied, using their output name.  The
    return value is unaffected by 'update' or 'dry_run': it is simply
    the list of all files under 'src', with the names changed to be
    under 'dst'.

    'preserve_mode' and 'preserve_times' are the same as for
    'copy_file'; note that they only apply to regular files, not to
    directories.  If 'preserve_symlinks' is true, symlinks will be
    copied as symlinks (on platforms that support them!); otherwise
    (the default), the destination of the symlink will be copied.
    'update' and 'verbose' are the same as for 'copy_file'.
    """
    from distutils.file_util import copy_file

    if not dry_run and not os.path.isdir(src):
        raise DistutilsFileError("cannot copy tree '%s': not a directory" % src)
    try:
        names = os.listdir(src)
    except OSError as e:
        if dry_run:
            names = []
        else:
            raise DistutilsFileError(
                "error listing files in '{}': {}".format(src, e.strerror)
            )

    if not dry_run:
        mkpath(dst, verbose=verbose)

    outputs = []

    for n in names:
        src_name = os.path.join(src, n)
        dst_name = os.path.join(dst, n)

        if n.startswith('.nfs'):
            # skip NFS rename files
            continue

        if preserve_symlinks and os.path.islink(src_name):
            link_dest = os.readlink(src_name)
            if verbose >= 1:
                log.info("linking %s -> %s", dst_name, link_dest)
            if not dry_run:
                os.symlink(link_dest, dst_name)
            outputs.append(dst_name)

        elif os.path.isdir(src_name):
            outputs.extend(
                copy_tree(
                    src_name,
                    dst_name,
                    preserve_mode,
                    preserve_times,
                    preserve_symlinks,
                    update,
                    verbose=verbose,
                    dry_run=dry_run,
                )
            )
        else:
            copy_file(
                src_name,
                dst_name,
                preserve_mode,
                preserve_times,
                update,
                verbose=verbose,
                dry_run=dry_run,
            )
            outputs.append(dst_name)

    return outputs


def _build_cmdtuple(path, cmdtuples):
    """Helper for remove_tree()."""
    for f in os.listdir(path):
        real_f = os.path.join(path, f)
        if os.path.isdir(real_f) and not os.path.islink(real_f):
            _build_cmdtuple(real_f, cmdtuples)
        else:
            cmdtuples.append((os.remove, real_f))
    cmdtuples.append((os.rmdir, path))


def remove_tree(directory, verbose=1, dry_run=0):
    """Recursively remove an entire directory tree.

    Any errors are ignored (apart from being reported to stdout if 'verbose'
    is true).
    """
    global _path_created

    if verbose >= 1:
        log.info("removing '%s' (and everything under it)", directory)
    if dry_run:
        return
    cmdtuples = []
    _build_cmdtuple(directory, cmdtuples)
    for cmd in cmdtuples:
        try:
            cmd[0](cmd[1])
            # remove dir from cache if it's already there
            abspath = os.path.abspath(cmd[1])
            if abspath in _path_created:
                _path_created.pop(abspath)
        except OSError as exc:
            log.warning("error removing %s: %s", directory, exc)


def ensure_relative(path):
    """Take the full path 'path', and make it a relative path.

    This is useful to make 'path' the second argument to os.path.join().
    """
    drive, path = os.path.splitdrive(path)
    if path[0:1] == os.sep:
        path = drive + path[1:]
    return path
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/dist.py0000644000175100001730000014177614467657412021413 0ustar00runnerdocker"""distutils.dist

Provides the Distribution class, which represents the module distribution
being built/installed/distributed.
"""

import sys
import os
import re
import pathlib
import contextlib
import logging
from email import message_from_file

try:
    import warnings
except ImportError:
    warnings = None

from .errors import (
    DistutilsOptionError,
    DistutilsModuleError,
    DistutilsArgError,
    DistutilsClassError,
)
from .fancy_getopt import FancyGetopt, translate_longopt
from .util import check_environ, strtobool, rfc822_escape
from ._log import log
from .debug import DEBUG

# Regex to define acceptable Distutils command names.  This is not *quite*
# the same as a Python NAME -- I don't allow leading underscores.  The fact
# that they're very similar is no coincidence; the default naming scheme is
# to look for a Python module named after the command.
command_re = re.compile(r'^[a-zA-Z]([a-zA-Z0-9_]*)$')


def _ensure_list(value, fieldname):
    if isinstance(value, str):
        # a string containing comma separated values is okay.  It will
        # be converted to a list by Distribution.finalize_options().
        pass
    elif not isinstance(value, list):
        # passing a tuple or an iterator perhaps, warn and convert
        typename = type(value).__name__
        msg = "Warning: '{fieldname}' should be a list, got type '{typename}'"
        msg = msg.format(**locals())
        log.warning(msg)
        value = list(value)
    return value


class Distribution:
    """The core of the Distutils.  Most of the work hiding behind 'setup'
    is really done within a Distribution instance, which farms the work out
    to the Distutils commands specified on the command line.

    Setup scripts will almost never instantiate Distribution directly,
    unless the 'setup()' function is totally inadequate to their needs.
    However, it is conceivable that a setup script might wish to subclass
    Distribution for some specialized purpose, and then pass the subclass
    to 'setup()' as the 'distclass' keyword argument.  If so, it is
    necessary to respect the expectations that 'setup' has of Distribution.
    See the code for 'setup()', in core.py, for details.
    """

    # 'global_options' describes the command-line options that may be
    # supplied to the setup script prior to any actual commands.
    # Eg. "./setup.py -n" or "./setup.py --quiet" both take advantage of
    # these global options.  This list should be kept to a bare minimum,
    # since every global option is also valid as a command option -- and we
    # don't want to pollute the commands with too many options that they
    # have minimal control over.
    # The fourth entry for verbose means that it can be repeated.
    global_options = [
        ('verbose', 'v', "run verbosely (default)", 1),
        ('quiet', 'q', "run quietly (turns verbosity off)"),
        ('dry-run', 'n', "don't actually do anything"),
        ('help', 'h', "show detailed help message"),
        ('no-user-cfg', None, 'ignore pydistutils.cfg in your home directory'),
    ]

    # 'common_usage' is a short (2-3 line) string describing the common
    # usage of the setup script.
    common_usage = """\
Common commands: (see '--help-commands' for more)

  setup.py build      will build the package underneath 'build/'
  setup.py install    will install the package
"""

    # options that are not propagated to the commands
    display_options = [
        ('help-commands', None, "list all available commands"),
        ('name', None, "print package name"),
        ('version', 'V', "print package version"),
        ('fullname', None, "print -"),
        ('author', None, "print the author's name"),
        ('author-email', None, "print the author's email address"),
        ('maintainer', None, "print the maintainer's name"),
        ('maintainer-email', None, "print the maintainer's email address"),
        ('contact', None, "print the maintainer's name if known, else the author's"),
        (
            'contact-email',
            None,
            "print the maintainer's email address if known, else the author's",
        ),
        ('url', None, "print the URL for this package"),
        ('license', None, "print the license of the package"),
        ('licence', None, "alias for --license"),
        ('description', None, "print the package description"),
        ('long-description', None, "print the long package description"),
        ('platforms', None, "print the list of platforms"),
        ('classifiers', None, "print the list of classifiers"),
        ('keywords', None, "print the list of keywords"),
        ('provides', None, "print the list of packages/modules provided"),
        ('requires', None, "print the list of packages/modules required"),
        ('obsoletes', None, "print the list of packages/modules made obsolete"),
    ]
    display_option_names = [translate_longopt(x[0]) for x in display_options]

    # negative options are options that exclude other options
    negative_opt = {'quiet': 'verbose'}

    # -- Creation/initialization methods -------------------------------

    def __init__(self, attrs=None):  # noqa: C901
        """Construct a new Distribution instance: initialize all the
        attributes of a Distribution, and then use 'attrs' (a dictionary
        mapping attribute names to values) to assign some of those
        attributes their "real" values.  (Any attributes not mentioned in
        'attrs' will be assigned to some null value: 0, None, an empty list
        or dictionary, etc.)  Most importantly, initialize the
        'command_obj' attribute to the empty dictionary; this will be
        filled in with real command objects by 'parse_command_line()'.
        """

        # Default values for our command-line options
        self.verbose = 1
        self.dry_run = 0
        self.help = 0
        for attr in self.display_option_names:
            setattr(self, attr, 0)

        # Store the distribution meta-data (name, version, author, and so
        # forth) in a separate object -- we're getting to have enough
        # information here (and enough command-line options) that it's
        # worth it.  Also delegate 'get_XXX()' methods to the 'metadata'
        # object in a sneaky and underhanded (but efficient!) way.
        self.metadata = DistributionMetadata()
        for basename in self.metadata._METHOD_BASENAMES:
            method_name = "get_" + basename
            setattr(self, method_name, getattr(self.metadata, method_name))

        # 'cmdclass' maps command names to class objects, so we
        # can 1) quickly figure out which class to instantiate when
        # we need to create a new command object, and 2) have a way
        # for the setup script to override command classes
        self.cmdclass = {}

        # 'command_packages' is a list of packages in which commands
        # are searched for.  The factory for command 'foo' is expected
        # to be named 'foo' in the module 'foo' in one of the packages
        # named here.  This list is searched from the left; an error
        # is raised if no named package provides the command being
        # searched for.  (Always access using get_command_packages().)
        self.command_packages = None

        # 'script_name' and 'script_args' are usually set to sys.argv[0]
        # and sys.argv[1:], but they can be overridden when the caller is
        # not necessarily a setup script run from the command-line.
        self.script_name = None
        self.script_args = None

        # 'command_options' is where we store command options between
        # parsing them (from config files, the command-line, etc.) and when
        # they are actually needed -- ie. when the command in question is
        # instantiated.  It is a dictionary of dictionaries of 2-tuples:
        #   command_options = { command_name : { option : (source, value) } }
        self.command_options = {}

        # 'dist_files' is the list of (command, pyversion, file) that
        # have been created by any dist commands run so far. This is
        # filled regardless of whether the run is dry or not. pyversion
        # gives sysconfig.get_python_version() if the dist file is
        # specific to a Python version, 'any' if it is good for all
        # Python versions on the target platform, and '' for a source
        # file. pyversion should not be used to specify minimum or
        # maximum required Python versions; use the metainfo for that
        # instead.
        self.dist_files = []

        # These options are really the business of various commands, rather
        # than of the Distribution itself.  We provide aliases for them in
        # Distribution as a convenience to the developer.
        self.packages = None
        self.package_data = {}
        self.package_dir = None
        self.py_modules = None
        self.libraries = None
        self.headers = None
        self.ext_modules = None
        self.ext_package = None
        self.include_dirs = None
        self.extra_path = None
        self.scripts = None
        self.data_files = None
        self.password = ''

        # And now initialize bookkeeping stuff that can't be supplied by
        # the caller at all.  'command_obj' maps command names to
        # Command instances -- that's how we enforce that every command
        # class is a singleton.
        self.command_obj = {}

        # 'have_run' maps command names to boolean values; it keeps track
        # of whether we have actually run a particular command, to make it
        # cheap to "run" a command whenever we think we might need to -- if
        # it's already been done, no need for expensive filesystem
        # operations, we just check the 'have_run' dictionary and carry on.
        # It's only safe to query 'have_run' for a command class that has
        # been instantiated -- a false value will be inserted when the
        # command object is created, and replaced with a true value when
        # the command is successfully run.  Thus it's probably best to use
        # '.get()' rather than a straight lookup.
        self.have_run = {}

        # Now we'll use the attrs dictionary (ultimately, keyword args from
        # the setup script) to possibly override any or all of these
        # distribution options.

        if attrs:
            # Pull out the set of command options and work on them
            # specifically.  Note that this order guarantees that aliased
            # command options will override any supplied redundantly
            # through the general options dictionary.
            options = attrs.get('options')
            if options is not None:
                del attrs['options']
                for command, cmd_options in options.items():
                    opt_dict = self.get_option_dict(command)
                    for opt, val in cmd_options.items():
                        opt_dict[opt] = ("setup script", val)

            if 'licence' in attrs:
                attrs['license'] = attrs['licence']
                del attrs['licence']
                msg = "'licence' distribution option is deprecated; use 'license'"
                if warnings is not None:
                    warnings.warn(msg)
                else:
                    sys.stderr.write(msg + "\n")

            # Now work on the rest of the attributes.  Any attribute that's
            # not already defined is invalid!
            for key, val in attrs.items():
                if hasattr(self.metadata, "set_" + key):
                    getattr(self.metadata, "set_" + key)(val)
                elif hasattr(self.metadata, key):
                    setattr(self.metadata, key, val)
                elif hasattr(self, key):
                    setattr(self, key, val)
                else:
                    msg = "Unknown distribution option: %s" % repr(key)
                    warnings.warn(msg)

        # no-user-cfg is handled before other command line args
        # because other args override the config files, and this
        # one is needed before we can load the config files.
        # If attrs['script_args'] wasn't passed, assume false.
        #
        # This also make sure we just look at the global options
        self.want_user_cfg = True

        if self.script_args is not None:
            for arg in self.script_args:
                if not arg.startswith('-'):
                    break
                if arg == '--no-user-cfg':
                    self.want_user_cfg = False
                    break

        self.finalize_options()

    def get_option_dict(self, command):
        """Get the option dictionary for a given command.  If that
        command's option dictionary hasn't been created yet, then create it
        and return the new dictionary; otherwise, return the existing
        option dictionary.
        """
        dict = self.command_options.get(command)
        if dict is None:
            dict = self.command_options[command] = {}
        return dict

    def dump_option_dicts(self, header=None, commands=None, indent=""):
        from pprint import pformat

        if commands is None:  # dump all command option dicts
            commands = sorted(self.command_options.keys())

        if header is not None:
            self.announce(indent + header)
            indent = indent + "  "

        if not commands:
            self.announce(indent + "no commands known yet")
            return

        for cmd_name in commands:
            opt_dict = self.command_options.get(cmd_name)
            if opt_dict is None:
                self.announce(indent + "no option dict for '%s' command" % cmd_name)
            else:
                self.announce(indent + "option dict for '%s' command:" % cmd_name)
                out = pformat(opt_dict)
                for line in out.split('\n'):
                    self.announce(indent + "  " + line)

    # -- Config file finding/parsing methods ---------------------------

    def find_config_files(self):
        """Find as many configuration files as should be processed for this
        platform, and return a list of filenames in the order in which they
        should be parsed.  The filenames returned are guaranteed to exist
        (modulo nasty race conditions).

        There are multiple possible config files:
        - distutils.cfg in the Distutils installation directory (i.e.
          where the top-level Distutils __inst__.py file lives)
        - a file in the user's home directory named .pydistutils.cfg
          on Unix and pydistutils.cfg on Windows/Mac; may be disabled
          with the ``--no-user-cfg`` option
        - setup.cfg in the current directory
        - a file named by an environment variable
        """
        check_environ()
        files = [str(path) for path in self._gen_paths() if os.path.isfile(path)]

        if DEBUG:
            self.announce("using config files: %s" % ', '.join(files))

        return files

    def _gen_paths(self):
        # The system-wide Distutils config file
        sys_dir = pathlib.Path(sys.modules['distutils'].__file__).parent
        yield sys_dir / "distutils.cfg"

        # The per-user config file
        prefix = '.' * (os.name == 'posix')
        filename = prefix + 'pydistutils.cfg'
        if self.want_user_cfg:
            yield pathlib.Path('~').expanduser() / filename

        # All platforms support local setup.cfg
        yield pathlib.Path('setup.cfg')

        # Additional config indicated in the environment
        with contextlib.suppress(TypeError):
            yield pathlib.Path(os.getenv("DIST_EXTRA_CONFIG"))

    def parse_config_files(self, filenames=None):  # noqa: C901
        from configparser import ConfigParser

        # Ignore install directory options if we have a venv
        if sys.prefix != sys.base_prefix:
            ignore_options = [
                'install-base',
                'install-platbase',
                'install-lib',
                'install-platlib',
                'install-purelib',
                'install-headers',
                'install-scripts',
                'install-data',
                'prefix',
                'exec-prefix',
                'home',
                'user',
                'root',
            ]
        else:
            ignore_options = []

        ignore_options = frozenset(ignore_options)

        if filenames is None:
            filenames = self.find_config_files()

        if DEBUG:
            self.announce("Distribution.parse_config_files():")

        parser = ConfigParser()
        for filename in filenames:
            if DEBUG:
                self.announce("  reading %s" % filename)
            parser.read(filename)
            for section in parser.sections():
                options = parser.options(section)
                opt_dict = self.get_option_dict(section)

                for opt in options:
                    if opt != '__name__' and opt not in ignore_options:
                        val = parser.get(section, opt)
                        opt = opt.replace('-', '_')
                        opt_dict[opt] = (filename, val)

            # Make the ConfigParser forget everything (so we retain
            # the original filenames that options come from)
            parser.__init__()

        # If there was a "global" section in the config file, use it
        # to set Distribution options.

        if 'global' in self.command_options:
            for opt, (src, val) in self.command_options['global'].items():
                alias = self.negative_opt.get(opt)
                try:
                    if alias:
                        setattr(self, alias, not strtobool(val))
                    elif opt in ('verbose', 'dry_run'):  # ugh!
                        setattr(self, opt, strtobool(val))
                    else:
                        setattr(self, opt, val)
                except ValueError as msg:
                    raise DistutilsOptionError(msg)

    # -- Command-line parsing methods ----------------------------------

    def parse_command_line(self):
        """Parse the setup script's command line, taken from the
        'script_args' instance attribute (which defaults to 'sys.argv[1:]'
        -- see 'setup()' in core.py).  This list is first processed for
        "global options" -- options that set attributes of the Distribution
        instance.  Then, it is alternately scanned for Distutils commands
        and options for that command.  Each new command terminates the
        options for the previous command.  The allowed options for a
        command are determined by the 'user_options' attribute of the
        command class -- thus, we have to be able to load command classes
        in order to parse the command line.  Any error in that 'options'
        attribute raises DistutilsGetoptError; any error on the
        command-line raises DistutilsArgError.  If no Distutils commands
        were found on the command line, raises DistutilsArgError.  Return
        true if command-line was successfully parsed and we should carry
        on with executing commands; false if no errors but we shouldn't
        execute commands (currently, this only happens if user asks for
        help).
        """
        #
        # We now have enough information to show the Macintosh dialog
        # that allows the user to interactively specify the "command line".
        #
        toplevel_options = self._get_toplevel_options()

        # We have to parse the command line a bit at a time -- global
        # options, then the first command, then its options, and so on --
        # because each command will be handled by a different class, and
        # the options that are valid for a particular class aren't known
        # until we have loaded the command class, which doesn't happen
        # until we know what the command is.

        self.commands = []
        parser = FancyGetopt(toplevel_options + self.display_options)
        parser.set_negative_aliases(self.negative_opt)
        parser.set_aliases({'licence': 'license'})
        args = parser.getopt(args=self.script_args, object=self)
        option_order = parser.get_option_order()
        logging.getLogger().setLevel(logging.WARN - 10 * self.verbose)

        # for display options we return immediately
        if self.handle_display_options(option_order):
            return
        while args:
            args = self._parse_command_opts(parser, args)
            if args is None:  # user asked for help (and got it)
                return

        # Handle the cases of --help as a "global" option, ie.
        # "setup.py --help" and "setup.py --help command ...".  For the
        # former, we show global options (--verbose, --dry-run, etc.)
        # and display-only options (--name, --version, etc.); for the
        # latter, we omit the display-only options and show help for
        # each command listed on the command line.
        if self.help:
            self._show_help(
                parser, display_options=len(self.commands) == 0, commands=self.commands
            )
            return

        # Oops, no commands found -- an end-user error
        if not self.commands:
            raise DistutilsArgError("no commands supplied")

        # All is well: return true
        return True

    def _get_toplevel_options(self):
        """Return the non-display options recognized at the top level.

        This includes options that are recognized *only* at the top
        level as well as options recognized for commands.
        """
        return self.global_options + [
            (
                "command-packages=",
                None,
                "list of packages that provide distutils commands",
            ),
        ]

    def _parse_command_opts(self, parser, args):  # noqa: C901
        """Parse the command-line options for a single command.
        'parser' must be a FancyGetopt instance; 'args' must be the list
        of arguments, starting with the current command (whose options
        we are about to parse).  Returns a new version of 'args' with
        the next command at the front of the list; will be the empty
        list if there are no more commands on the command line.  Returns
        None if the user asked for help on this command.
        """
        # late import because of mutual dependence between these modules
        from distutils.cmd import Command

        # Pull the current command from the head of the command line
        command = args[0]
        if not command_re.match(command):
            raise SystemExit("invalid command name '%s'" % command)
        self.commands.append(command)

        # Dig up the command class that implements this command, so we
        # 1) know that it's a valid command, and 2) know which options
        # it takes.
        try:
            cmd_class = self.get_command_class(command)
        except DistutilsModuleError as msg:
            raise DistutilsArgError(msg)

        # Require that the command class be derived from Command -- want
        # to be sure that the basic "command" interface is implemented.
        if not issubclass(cmd_class, Command):
            raise DistutilsClassError(
                "command class %s must subclass Command" % cmd_class
            )

        # Also make sure that the command object provides a list of its
        # known options.
        if not (
            hasattr(cmd_class, 'user_options')
            and isinstance(cmd_class.user_options, list)
        ):
            msg = (
                "command class %s must provide "
                "'user_options' attribute (a list of tuples)"
            )
            raise DistutilsClassError(msg % cmd_class)

        # If the command class has a list of negative alias options,
        # merge it in with the global negative aliases.
        negative_opt = self.negative_opt
        if hasattr(cmd_class, 'negative_opt'):
            negative_opt = negative_opt.copy()
            negative_opt.update(cmd_class.negative_opt)

        # Check for help_options in command class.  They have a different
        # format (tuple of four) so we need to preprocess them here.
        if hasattr(cmd_class, 'help_options') and isinstance(
            cmd_class.help_options, list
        ):
            help_options = fix_help_options(cmd_class.help_options)
        else:
            help_options = []

        # All commands support the global options too, just by adding
        # in 'global_options'.
        parser.set_option_table(
            self.global_options + cmd_class.user_options + help_options
        )
        parser.set_negative_aliases(negative_opt)
        (args, opts) = parser.getopt(args[1:])
        if hasattr(opts, 'help') and opts.help:
            self._show_help(parser, display_options=0, commands=[cmd_class])
            return

        if hasattr(cmd_class, 'help_options') and isinstance(
            cmd_class.help_options, list
        ):
            help_option_found = 0
            for help_option, short, desc, func in cmd_class.help_options:
                if hasattr(opts, parser.get_attr_name(help_option)):
                    help_option_found = 1
                    if callable(func):
                        func()
                    else:
                        raise DistutilsClassError(
                            "invalid help function %r for help option '%s': "
                            "must be a callable object (function, etc.)"
                            % (func, help_option)
                        )

            if help_option_found:
                return

        # Put the options from the command-line into their official
        # holding pen, the 'command_options' dictionary.
        opt_dict = self.get_option_dict(command)
        for name, value in vars(opts).items():
            opt_dict[name] = ("command line", value)

        return args

    def finalize_options(self):
        """Set final values for all the options on the Distribution
        instance, analogous to the .finalize_options() method of Command
        objects.
        """
        for attr in ('keywords', 'platforms'):
            value = getattr(self.metadata, attr)
            if value is None:
                continue
            if isinstance(value, str):
                value = [elm.strip() for elm in value.split(',')]
                setattr(self.metadata, attr, value)

    def _show_help(self, parser, global_options=1, display_options=1, commands=[]):
        """Show help for the setup script command-line in the form of
        several lists of command-line options.  'parser' should be a
        FancyGetopt instance; do not expect it to be returned in the
        same state, as its option table will be reset to make it
        generate the correct help text.

        If 'global_options' is true, lists the global options:
        --verbose, --dry-run, etc.  If 'display_options' is true, lists
        the "display-only" options: --name, --version, etc.  Finally,
        lists per-command help for every command name or command class
        in 'commands'.
        """
        # late import because of mutual dependence between these modules
        from distutils.core import gen_usage
        from distutils.cmd import Command

        if global_options:
            if display_options:
                options = self._get_toplevel_options()
            else:
                options = self.global_options
            parser.set_option_table(options)
            parser.print_help(self.common_usage + "\nGlobal options:")
            print('')

        if display_options:
            parser.set_option_table(self.display_options)
            parser.print_help(
                "Information display options (just display "
                + "information, ignore any commands)"
            )
            print('')

        for command in self.commands:
            if isinstance(command, type) and issubclass(command, Command):
                klass = command
            else:
                klass = self.get_command_class(command)
            if hasattr(klass, 'help_options') and isinstance(klass.help_options, list):
                parser.set_option_table(
                    klass.user_options + fix_help_options(klass.help_options)
                )
            else:
                parser.set_option_table(klass.user_options)
            parser.print_help("Options for '%s' command:" % klass.__name__)
            print('')

        print(gen_usage(self.script_name))

    def handle_display_options(self, option_order):
        """If there were any non-global "display-only" options
        (--help-commands or the metadata display options) on the command
        line, display the requested info and return true; else return
        false.
        """
        from distutils.core import gen_usage

        # User just wants a list of commands -- we'll print it out and stop
        # processing now (ie. if they ran "setup --help-commands foo bar",
        # we ignore "foo bar").
        if self.help_commands:
            self.print_commands()
            print('')
            print(gen_usage(self.script_name))
            return 1

        # If user supplied any of the "display metadata" options, then
        # display that metadata in the order in which the user supplied the
        # metadata options.
        any_display_options = 0
        is_display_option = {}
        for option in self.display_options:
            is_display_option[option[0]] = 1

        for opt, val in option_order:
            if val and is_display_option.get(opt):
                opt = translate_longopt(opt)
                value = getattr(self.metadata, "get_" + opt)()
                if opt in ('keywords', 'platforms'):
                    print(','.join(value))
                elif opt in ('classifiers', 'provides', 'requires', 'obsoletes'):
                    print('\n'.join(value))
                else:
                    print(value)
                any_display_options = 1

        return any_display_options

    def print_command_list(self, commands, header, max_length):
        """Print a subset of the list of all commands -- used by
        'print_commands()'.
        """
        print(header + ":")

        for cmd in commands:
            klass = self.cmdclass.get(cmd)
            if not klass:
                klass = self.get_command_class(cmd)
            try:
                description = klass.description
            except AttributeError:
                description = "(no description available)"

            print("  %-*s  %s" % (max_length, cmd, description))

    def print_commands(self):
        """Print out a help message listing all available commands with a
        description of each.  The list is divided into "standard commands"
        (listed in distutils.command.__all__) and "extra commands"
        (mentioned in self.cmdclass, but not a standard command).  The
        descriptions come from the command class attribute
        'description'.
        """
        import distutils.command

        std_commands = distutils.command.__all__
        is_std = {}
        for cmd in std_commands:
            is_std[cmd] = 1

        extra_commands = []
        for cmd in self.cmdclass.keys():
            if not is_std.get(cmd):
                extra_commands.append(cmd)

        max_length = 0
        for cmd in std_commands + extra_commands:
            if len(cmd) > max_length:
                max_length = len(cmd)

        self.print_command_list(std_commands, "Standard commands", max_length)
        if extra_commands:
            print()
            self.print_command_list(extra_commands, "Extra commands", max_length)

    def get_command_list(self):
        """Get a list of (command, description) tuples.
        The list is divided into "standard commands" (listed in
        distutils.command.__all__) and "extra commands" (mentioned in
        self.cmdclass, but not a standard command).  The descriptions come
        from the command class attribute 'description'.
        """
        # Currently this is only used on Mac OS, for the Mac-only GUI
        # Distutils interface (by Jack Jansen)
        import distutils.command

        std_commands = distutils.command.__all__
        is_std = {}
        for cmd in std_commands:
            is_std[cmd] = 1

        extra_commands = []
        for cmd in self.cmdclass.keys():
            if not is_std.get(cmd):
                extra_commands.append(cmd)

        rv = []
        for cmd in std_commands + extra_commands:
            klass = self.cmdclass.get(cmd)
            if not klass:
                klass = self.get_command_class(cmd)
            try:
                description = klass.description
            except AttributeError:
                description = "(no description available)"
            rv.append((cmd, description))
        return rv

    # -- Command class/object methods ----------------------------------

    def get_command_packages(self):
        """Return a list of packages from which commands are loaded."""
        pkgs = self.command_packages
        if not isinstance(pkgs, list):
            if pkgs is None:
                pkgs = ''
            pkgs = [pkg.strip() for pkg in pkgs.split(',') if pkg != '']
            if "distutils.command" not in pkgs:
                pkgs.insert(0, "distutils.command")
            self.command_packages = pkgs
        return pkgs

    def get_command_class(self, command):
        """Return the class that implements the Distutils command named by
        'command'.  First we check the 'cmdclass' dictionary; if the
        command is mentioned there, we fetch the class object from the
        dictionary and return it.  Otherwise we load the command module
        ("distutils.command." + command) and fetch the command class from
        the module.  The loaded class is also stored in 'cmdclass'
        to speed future calls to 'get_command_class()'.

        Raises DistutilsModuleError if the expected module could not be
        found, or if that module does not define the expected class.
        """
        klass = self.cmdclass.get(command)
        if klass:
            return klass

        for pkgname in self.get_command_packages():
            module_name = "{}.{}".format(pkgname, command)
            klass_name = command

            try:
                __import__(module_name)
                module = sys.modules[module_name]
            except ImportError:
                continue

            try:
                klass = getattr(module, klass_name)
            except AttributeError:
                raise DistutilsModuleError(
                    "invalid command '%s' (no class '%s' in module '%s')"
                    % (command, klass_name, module_name)
                )

            self.cmdclass[command] = klass
            return klass

        raise DistutilsModuleError("invalid command '%s'" % command)

    def get_command_obj(self, command, create=1):
        """Return the command object for 'command'.  Normally this object
        is cached on a previous call to 'get_command_obj()'; if no command
        object for 'command' is in the cache, then we either create and
        return it (if 'create' is true) or return None.
        """
        cmd_obj = self.command_obj.get(command)
        if not cmd_obj and create:
            if DEBUG:
                self.announce(
                    "Distribution.get_command_obj(): "
                    "creating '%s' command object" % command
                )

            klass = self.get_command_class(command)
            cmd_obj = self.command_obj[command] = klass(self)
            self.have_run[command] = 0

            # Set any options that were supplied in config files
            # or on the command line.  (NB. support for error
            # reporting is lame here: any errors aren't reported
            # until 'finalize_options()' is called, which means
            # we won't report the source of the error.)
            options = self.command_options.get(command)
            if options:
                self._set_command_options(cmd_obj, options)

        return cmd_obj

    def _set_command_options(self, command_obj, option_dict=None):  # noqa: C901
        """Set the options for 'command_obj' from 'option_dict'.  Basically
        this means copying elements of a dictionary ('option_dict') to
        attributes of an instance ('command').

        'command_obj' must be a Command instance.  If 'option_dict' is not
        supplied, uses the standard option dictionary for this command
        (from 'self.command_options').
        """
        command_name = command_obj.get_command_name()
        if option_dict is None:
            option_dict = self.get_option_dict(command_name)

        if DEBUG:
            self.announce("  setting options for '%s' command:" % command_name)
        for option, (source, value) in option_dict.items():
            if DEBUG:
                self.announce("    {} = {} (from {})".format(option, value, source))
            try:
                bool_opts = [translate_longopt(o) for o in command_obj.boolean_options]
            except AttributeError:
                bool_opts = []
            try:
                neg_opt = command_obj.negative_opt
            except AttributeError:
                neg_opt = {}

            try:
                is_string = isinstance(value, str)
                if option in neg_opt and is_string:
                    setattr(command_obj, neg_opt[option], not strtobool(value))
                elif option in bool_opts and is_string:
                    setattr(command_obj, option, strtobool(value))
                elif hasattr(command_obj, option):
                    setattr(command_obj, option, value)
                else:
                    raise DistutilsOptionError(
                        "error in %s: command '%s' has no such option '%s'"
                        % (source, command_name, option)
                    )
            except ValueError as msg:
                raise DistutilsOptionError(msg)

    def reinitialize_command(self, command, reinit_subcommands=0):
        """Reinitializes a command to the state it was in when first
        returned by 'get_command_obj()': ie., initialized but not yet
        finalized.  This provides the opportunity to sneak option
        values in programmatically, overriding or supplementing
        user-supplied values from the config files and command line.
        You'll have to re-finalize the command object (by calling
        'finalize_options()' or 'ensure_finalized()') before using it for
        real.

        'command' should be a command name (string) or command object.  If
        'reinit_subcommands' is true, also reinitializes the command's
        sub-commands, as declared by the 'sub_commands' class attribute (if
        it has one).  See the "install" command for an example.  Only
        reinitializes the sub-commands that actually matter, ie. those
        whose test predicates return true.

        Returns the reinitialized command object.
        """
        from distutils.cmd import Command

        if not isinstance(command, Command):
            command_name = command
            command = self.get_command_obj(command_name)
        else:
            command_name = command.get_command_name()

        if not command.finalized:
            return command
        command.initialize_options()
        command.finalized = 0
        self.have_run[command_name] = 0
        self._set_command_options(command)

        if reinit_subcommands:
            for sub in command.get_sub_commands():
                self.reinitialize_command(sub, reinit_subcommands)

        return command

    # -- Methods that operate on the Distribution ----------------------

    def announce(self, msg, level=logging.INFO):
        log.log(level, msg)

    def run_commands(self):
        """Run each command that was seen on the setup script command line.
        Uses the list of commands found and cache of command objects
        created by 'get_command_obj()'.
        """
        for cmd in self.commands:
            self.run_command(cmd)

    # -- Methods that operate on its Commands --------------------------

    def run_command(self, command):
        """Do whatever it takes to run a command (including nothing at all,
        if the command has already been run).  Specifically: if we have
        already created and run the command named by 'command', return
        silently without doing anything.  If the command named by 'command'
        doesn't even have a command object yet, create one.  Then invoke
        'run()' on that command object (or an existing one).
        """
        # Already been here, done that? then return silently.
        if self.have_run.get(command):
            return

        log.info("running %s", command)
        cmd_obj = self.get_command_obj(command)
        cmd_obj.ensure_finalized()
        cmd_obj.run()
        self.have_run[command] = 1

    # -- Distribution query methods ------------------------------------

    def has_pure_modules(self):
        return len(self.packages or self.py_modules or []) > 0

    def has_ext_modules(self):
        return self.ext_modules and len(self.ext_modules) > 0

    def has_c_libraries(self):
        return self.libraries and len(self.libraries) > 0

    def has_modules(self):
        return self.has_pure_modules() or self.has_ext_modules()

    def has_headers(self):
        return self.headers and len(self.headers) > 0

    def has_scripts(self):
        return self.scripts and len(self.scripts) > 0

    def has_data_files(self):
        return self.data_files and len(self.data_files) > 0

    def is_pure(self):
        return (
            self.has_pure_modules()
            and not self.has_ext_modules()
            and not self.has_c_libraries()
        )

    # -- Metadata query methods ----------------------------------------

    # If you're looking for 'get_name()', 'get_version()', and so forth,
    # they are defined in a sneaky way: the constructor binds self.get_XXX
    # to self.metadata.get_XXX.  The actual code is in the
    # DistributionMetadata class, below.


class DistributionMetadata:
    """Dummy class to hold the distribution meta-data: name, version,
    author, and so forth.
    """

    _METHOD_BASENAMES = (
        "name",
        "version",
        "author",
        "author_email",
        "maintainer",
        "maintainer_email",
        "url",
        "license",
        "description",
        "long_description",
        "keywords",
        "platforms",
        "fullname",
        "contact",
        "contact_email",
        "classifiers",
        "download_url",
        # PEP 314
        "provides",
        "requires",
        "obsoletes",
    )

    def __init__(self, path=None):
        if path is not None:
            self.read_pkg_file(open(path))
        else:
            self.name = None
            self.version = None
            self.author = None
            self.author_email = None
            self.maintainer = None
            self.maintainer_email = None
            self.url = None
            self.license = None
            self.description = None
            self.long_description = None
            self.keywords = None
            self.platforms = None
            self.classifiers = None
            self.download_url = None
            # PEP 314
            self.provides = None
            self.requires = None
            self.obsoletes = None

    def read_pkg_file(self, file):
        """Reads the metadata values from a file object."""
        msg = message_from_file(file)

        def _read_field(name):
            value = msg[name]
            if value and value != "UNKNOWN":
                return value

        def _read_list(name):
            values = msg.get_all(name, None)
            if values == []:
                return None
            return values

        metadata_version = msg['metadata-version']
        self.name = _read_field('name')
        self.version = _read_field('version')
        self.description = _read_field('summary')
        # we are filling author only.
        self.author = _read_field('author')
        self.maintainer = None
        self.author_email = _read_field('author-email')
        self.maintainer_email = None
        self.url = _read_field('home-page')
        self.license = _read_field('license')

        if 'download-url' in msg:
            self.download_url = _read_field('download-url')
        else:
            self.download_url = None

        self.long_description = _read_field('description')
        self.description = _read_field('summary')

        if 'keywords' in msg:
            self.keywords = _read_field('keywords').split(',')

        self.platforms = _read_list('platform')
        self.classifiers = _read_list('classifier')

        # PEP 314 - these fields only exist in 1.1
        if metadata_version == '1.1':
            self.requires = _read_list('requires')
            self.provides = _read_list('provides')
            self.obsoletes = _read_list('obsoletes')
        else:
            self.requires = None
            self.provides = None
            self.obsoletes = None

    def write_pkg_info(self, base_dir):
        """Write the PKG-INFO file into the release tree."""
        with open(
            os.path.join(base_dir, 'PKG-INFO'), 'w', encoding='UTF-8'
        ) as pkg_info:
            self.write_pkg_file(pkg_info)

    def write_pkg_file(self, file):
        """Write the PKG-INFO format data to a file object."""
        version = '1.0'
        if (
            self.provides
            or self.requires
            or self.obsoletes
            or self.classifiers
            or self.download_url
        ):
            version = '1.1'

        # required fields
        file.write('Metadata-Version: %s\n' % version)
        file.write('Name: %s\n' % self.get_name())
        file.write('Version: %s\n' % self.get_version())

        def maybe_write(header, val):
            if val:
                file.write(f"{header}: {val}\n")

        # optional fields
        maybe_write("Summary", self.get_description())
        maybe_write("Home-page", self.get_url())
        maybe_write("Author", self.get_contact())
        maybe_write("Author-email", self.get_contact_email())
        maybe_write("License", self.get_license())
        maybe_write("Download-URL", self.download_url)
        maybe_write("Description", rfc822_escape(self.get_long_description() or ""))
        maybe_write("Keywords", ",".join(self.get_keywords()))

        self._write_list(file, 'Platform', self.get_platforms())
        self._write_list(file, 'Classifier', self.get_classifiers())

        # PEP 314
        self._write_list(file, 'Requires', self.get_requires())
        self._write_list(file, 'Provides', self.get_provides())
        self._write_list(file, 'Obsoletes', self.get_obsoletes())

    def _write_list(self, file, name, values):
        values = values or []
        for value in values:
            file.write('{}: {}\n'.format(name, value))

    # -- Metadata query methods ----------------------------------------

    def get_name(self):
        return self.name or "UNKNOWN"

    def get_version(self):
        return self.version or "0.0.0"

    def get_fullname(self):
        return "{}-{}".format(self.get_name(), self.get_version())

    def get_author(self):
        return self.author

    def get_author_email(self):
        return self.author_email

    def get_maintainer(self):
        return self.maintainer

    def get_maintainer_email(self):
        return self.maintainer_email

    def get_contact(self):
        return self.maintainer or self.author

    def get_contact_email(self):
        return self.maintainer_email or self.author_email

    def get_url(self):
        return self.url

    def get_license(self):
        return self.license

    get_licence = get_license

    def get_description(self):
        return self.description

    def get_long_description(self):
        return self.long_description

    def get_keywords(self):
        return self.keywords or []

    def set_keywords(self, value):
        self.keywords = _ensure_list(value, 'keywords')

    def get_platforms(self):
        return self.platforms

    def set_platforms(self, value):
        self.platforms = _ensure_list(value, 'platforms')

    def get_classifiers(self):
        return self.classifiers or []

    def set_classifiers(self, value):
        self.classifiers = _ensure_list(value, 'classifiers')

    def get_download_url(self):
        return self.download_url

    # PEP 314
    def get_requires(self):
        return self.requires or []

    def set_requires(self, value):
        import distutils.versionpredicate

        for v in value:
            distutils.versionpredicate.VersionPredicate(v)
        self.requires = list(value)

    def get_provides(self):
        return self.provides or []

    def set_provides(self, value):
        value = [v.strip() for v in value]
        for v in value:
            import distutils.versionpredicate

            distutils.versionpredicate.split_provision(v)
        self.provides = value

    def get_obsoletes(self):
        return self.obsoletes or []

    def set_obsoletes(self, value):
        import distutils.versionpredicate

        for v in value:
            distutils.versionpredicate.VersionPredicate(v)
        self.obsoletes = list(value)


def fix_help_options(options):
    """Convert a 4-tuple 'help_options' list as found in various command
    classes to the 3-tuple form required by FancyGetopt.
    """
    new_options = []
    for help_tuple in options:
        new_options.append(help_tuple[0:3])
    return new_options
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/errors.py0000644000175100001730000000700514467657412021746 0ustar00runnerdocker"""distutils.errors

Provides exceptions used by the Distutils modules.  Note that Distutils
modules may raise standard exceptions; in particular, SystemExit is
usually raised for errors that are obviously the end-user's fault
(eg. bad command-line arguments).

This module is safe to use in "from ... import *" mode; it only exports
symbols whose names start with "Distutils" and end with "Error"."""


class DistutilsError(Exception):
    """The root of all Distutils evil."""

    pass


class DistutilsModuleError(DistutilsError):
    """Unable to load an expected module, or to find an expected class
    within some module (in particular, command modules and classes)."""

    pass


class DistutilsClassError(DistutilsError):
    """Some command class (or possibly distribution class, if anyone
    feels a need to subclass Distribution) is found not to be holding
    up its end of the bargain, ie. implementing some part of the
    "command "interface."""

    pass


class DistutilsGetoptError(DistutilsError):
    """The option table provided to 'fancy_getopt()' is bogus."""

    pass


class DistutilsArgError(DistutilsError):
    """Raised by fancy_getopt in response to getopt.error -- ie. an
    error in the command line usage."""

    pass


class DistutilsFileError(DistutilsError):
    """Any problems in the filesystem: expected file not found, etc.
    Typically this is for problems that we detect before OSError
    could be raised."""

    pass


class DistutilsOptionError(DistutilsError):
    """Syntactic/semantic errors in command options, such as use of
    mutually conflicting options, or inconsistent options,
    badly-spelled values, etc.  No distinction is made between option
    values originating in the setup script, the command line, config
    files, or what-have-you -- but if we *know* something originated in
    the setup script, we'll raise DistutilsSetupError instead."""

    pass


class DistutilsSetupError(DistutilsError):
    """For errors that can be definitely blamed on the setup script,
    such as invalid keyword arguments to 'setup()'."""

    pass


class DistutilsPlatformError(DistutilsError):
    """We don't know how to do something on the current platform (but
    we do know how to do it on some platform) -- eg. trying to compile
    C files on a platform not supported by a CCompiler subclass."""

    pass


class DistutilsExecError(DistutilsError):
    """Any problems executing an external program (such as the C
    compiler, when compiling C files)."""

    pass


class DistutilsInternalError(DistutilsError):
    """Internal inconsistencies or impossibilities (obviously, this
    should never be seen if the code is working!)."""

    pass


class DistutilsTemplateError(DistutilsError):
    """Syntax error in a file list template."""


class DistutilsByteCompileError(DistutilsError):
    """Byte compile error."""


# Exception classes used by the CCompiler implementation classes
class CCompilerError(Exception):
    """Some compile/link operation failed."""


class PreprocessError(CCompilerError):
    """Failure to preprocess one or more C/C++ files."""


class CompileError(CCompilerError):
    """Failure to compile one or more C/C++ source files."""


class LibError(CCompilerError):
    """Failure to create a static library from one or more C/C++ object
    files."""


class LinkError(CCompilerError):
    """Failure to link one or more C/C++ object files into an executable
    or shared library file."""


class UnknownFileError(CCompilerError):
    """Attempt to process an unknown file type."""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/extension.py0000644000175100001730000002403614467657412022451 0ustar00runnerdocker"""distutils.extension

Provides the Extension class, used to describe C/C++ extension
modules in setup scripts."""

import os
import warnings

# This class is really only used by the "build_ext" command, so it might
# make sense to put it in distutils.command.build_ext.  However, that
# module is already big enough, and I want to make this class a bit more
# complex to simplify some common cases ("foo" module in "foo.c") and do
# better error-checking ("foo.c" actually exists).
#
# Also, putting this in build_ext.py means every setup script would have to
# import that large-ish module (indirectly, through distutils.core) in
# order to do anything.


class Extension:
    """Just a collection of attributes that describes an extension
    module and everything needed to build it (hopefully in a portable
    way, but there are hooks that let you be as unportable as you need).

    Instance attributes:
      name : string
        the full name of the extension, including any packages -- ie.
        *not* a filename or pathname, but Python dotted name
      sources : [string]
        list of source filenames, relative to the distribution root
        (where the setup script lives), in Unix form (slash-separated)
        for portability.  Source files may be C, C++, SWIG (.i),
        platform-specific resource files, or whatever else is recognized
        by the "build_ext" command as source for a Python extension.
      include_dirs : [string]
        list of directories to search for C/C++ header files (in Unix
        form for portability)
      define_macros : [(name : string, value : string|None)]
        list of macros to define; each macro is defined using a 2-tuple,
        where 'value' is either the string to define it to or None to
        define it without a particular value (equivalent of "#define
        FOO" in source or -DFOO on Unix C compiler command line)
      undef_macros : [string]
        list of macros to undefine explicitly
      library_dirs : [string]
        list of directories to search for C/C++ libraries at link time
      libraries : [string]
        list of library names (not filenames or paths) to link against
      runtime_library_dirs : [string]
        list of directories to search for C/C++ libraries at run time
        (for shared extensions, this is when the extension is loaded)
      extra_objects : [string]
        list of extra files to link with (eg. object files not implied
        by 'sources', static library that must be explicitly specified,
        binary resource files, etc.)
      extra_compile_args : [string]
        any extra platform- and compiler-specific information to use
        when compiling the source files in 'sources'.  For platforms and
        compilers where "command line" makes sense, this is typically a
        list of command-line arguments, but for other platforms it could
        be anything.
      extra_link_args : [string]
        any extra platform- and compiler-specific information to use
        when linking object files together to create the extension (or
        to create a new static Python interpreter).  Similar
        interpretation as for 'extra_compile_args'.
      export_symbols : [string]
        list of symbols to be exported from a shared extension.  Not
        used on all platforms, and not generally necessary for Python
        extensions, which typically export exactly one symbol: "init" +
        extension_name.
      swig_opts : [string]
        any extra options to pass to SWIG if a source file has the .i
        extension.
      depends : [string]
        list of files that the extension depends on
      language : string
        extension language (i.e. "c", "c++", "objc"). Will be detected
        from the source extensions if not provided.
      optional : boolean
        specifies that a build failure in the extension should not abort the
        build process, but simply not install the failing extension.
    """

    # When adding arguments to this constructor, be sure to update
    # setup_keywords in core.py.
    def __init__(
        self,
        name,
        sources,
        include_dirs=None,
        define_macros=None,
        undef_macros=None,
        library_dirs=None,
        libraries=None,
        runtime_library_dirs=None,
        extra_objects=None,
        extra_compile_args=None,
        extra_link_args=None,
        export_symbols=None,
        swig_opts=None,
        depends=None,
        language=None,
        optional=None,
        **kw  # To catch unknown keywords
    ):
        if not isinstance(name, str):
            raise AssertionError("'name' must be a string")
        if not (isinstance(sources, list) and all(isinstance(v, str) for v in sources)):
            raise AssertionError("'sources' must be a list of strings")

        self.name = name
        self.sources = sources
        self.include_dirs = include_dirs or []
        self.define_macros = define_macros or []
        self.undef_macros = undef_macros or []
        self.library_dirs = library_dirs or []
        self.libraries = libraries or []
        self.runtime_library_dirs = runtime_library_dirs or []
        self.extra_objects = extra_objects or []
        self.extra_compile_args = extra_compile_args or []
        self.extra_link_args = extra_link_args or []
        self.export_symbols = export_symbols or []
        self.swig_opts = swig_opts or []
        self.depends = depends or []
        self.language = language
        self.optional = optional

        # If there are unknown keyword options, warn about them
        if len(kw) > 0:
            options = [repr(option) for option in kw]
            options = ', '.join(sorted(options))
            msg = "Unknown Extension options: %s" % options
            warnings.warn(msg)

    def __repr__(self):
        return '<{}.{}({!r}) at {:#x}>'.format(
            self.__class__.__module__,
            self.__class__.__qualname__,
            self.name,
            id(self),
        )


def read_setup_file(filename):  # noqa: C901
    """Reads a Setup file and returns Extension instances."""
    from distutils.sysconfig import parse_makefile, expand_makefile_vars, _variable_rx

    from distutils.text_file import TextFile
    from distutils.util import split_quoted

    # First pass over the file to gather "VAR = VALUE" assignments.
    vars = parse_makefile(filename)

    # Second pass to gobble up the real content: lines of the form
    #    ... [ ...] [ ...] [ ...]
    file = TextFile(
        filename,
        strip_comments=1,
        skip_blanks=1,
        join_lines=1,
        lstrip_ws=1,
        rstrip_ws=1,
    )
    try:
        extensions = []

        while True:
            line = file.readline()
            if line is None:  # eof
                break
            if _variable_rx.match(line):  # VAR=VALUE, handled in first pass
                continue

            if line[0] == line[-1] == "*":
                file.warn("'%s' lines not handled yet" % line)
                continue

            line = expand_makefile_vars(line, vars)
            words = split_quoted(line)

            # NB. this parses a slightly different syntax than the old
            # makesetup script: here, there must be exactly one extension per
            # line, and it must be the first word of the line.  I have no idea
            # why the old syntax supported multiple extensions per line, as
            # they all wind up being the same.

            module = words[0]
            ext = Extension(module, [])
            append_next_word = None

            for word in words[1:]:
                if append_next_word is not None:
                    append_next_word.append(word)
                    append_next_word = None
                    continue

                suffix = os.path.splitext(word)[1]
                switch = word[0:2]
                value = word[2:]

                if suffix in (".c", ".cc", ".cpp", ".cxx", ".c++", ".m", ".mm"):
                    # hmm, should we do something about C vs. C++ sources?
                    # or leave it up to the CCompiler implementation to
                    # worry about?
                    ext.sources.append(word)
                elif switch == "-I":
                    ext.include_dirs.append(value)
                elif switch == "-D":
                    equals = value.find("=")
                    if equals == -1:  # bare "-DFOO" -- no value
                        ext.define_macros.append((value, None))
                    else:  # "-DFOO=blah"
                        ext.define_macros.append((value[0:equals], value[equals + 2 :]))
                elif switch == "-U":
                    ext.undef_macros.append(value)
                elif switch == "-C":  # only here 'cause makesetup has it!
                    ext.extra_compile_args.append(word)
                elif switch == "-l":
                    ext.libraries.append(value)
                elif switch == "-L":
                    ext.library_dirs.append(value)
                elif switch == "-R":
                    ext.runtime_library_dirs.append(value)
                elif word == "-rpath":
                    append_next_word = ext.runtime_library_dirs
                elif word == "-Xlinker":
                    append_next_word = ext.extra_link_args
                elif word == "-Xcompiler":
                    append_next_word = ext.extra_compile_args
                elif switch == "-u":
                    ext.extra_link_args.append(word)
                    if not value:
                        append_next_word = ext.extra_link_args
                elif suffix in (".a", ".so", ".sl", ".o", ".dylib"):
                    # NB. a really faithful emulation of makesetup would
                    # append a .o file to extra_objects only if it
                    # had a slash in it; otherwise, it would s/.o/.c/
                    # and append it to sources.  Hmmmm.
                    ext.extra_objects.append(word)
                else:
                    file.warn("unrecognized argument '%s'" % word)

            extensions.append(ext)
    finally:
        file.close()

    return extensions
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/fancy_getopt.py0000644000175100001730000004275314467657412023125 0ustar00runnerdocker"""distutils.fancy_getopt

Wrapper around the standard getopt module that provides the following
additional features:
  * short and long options are tied together
  * options have help strings, so fancy_getopt could potentially
    create a complete usage summary
  * options set attributes of a passed-in object
"""

import sys
import string
import re
import getopt
from .errors import DistutilsGetoptError, DistutilsArgError

# Much like command_re in distutils.core, this is close to but not quite
# the same as a Python NAME -- except, in the spirit of most GNU
# utilities, we use '-' in place of '_'.  (The spirit of LISP lives on!)
# The similarities to NAME are again not a coincidence...
longopt_pat = r'[a-zA-Z](?:[a-zA-Z0-9-]*)'
longopt_re = re.compile(r'^%s$' % longopt_pat)

# For recognizing "negative alias" options, eg. "quiet=!verbose"
neg_alias_re = re.compile("^({})=!({})$".format(longopt_pat, longopt_pat))

# This is used to translate long options to legitimate Python identifiers
# (for use as attributes of some object).
longopt_xlate = str.maketrans('-', '_')


class FancyGetopt:
    """Wrapper around the standard 'getopt()' module that provides some
    handy extra functionality:
      * short and long options are tied together
      * options have help strings, and help text can be assembled
        from them
      * options set attributes of a passed-in object
      * boolean options can have "negative aliases" -- eg. if
        --quiet is the "negative alias" of --verbose, then "--quiet"
        on the command line sets 'verbose' to false
    """

    def __init__(self, option_table=None):
        # The option table is (currently) a list of tuples.  The
        # tuples may have 3 or four values:
        #   (long_option, short_option, help_string [, repeatable])
        # if an option takes an argument, its long_option should have '='
        # appended; short_option should just be a single character, no ':'
        # in any case.  If a long_option doesn't have a corresponding
        # short_option, short_option should be None.  All option tuples
        # must have long options.
        self.option_table = option_table

        # 'option_index' maps long option names to entries in the option
        # table (ie. those 3-tuples).
        self.option_index = {}
        if self.option_table:
            self._build_index()

        # 'alias' records (duh) alias options; {'foo': 'bar'} means
        # --foo is an alias for --bar
        self.alias = {}

        # 'negative_alias' keeps track of options that are the boolean
        # opposite of some other option
        self.negative_alias = {}

        # These keep track of the information in the option table.  We
        # don't actually populate these structures until we're ready to
        # parse the command-line, since the 'option_table' passed in here
        # isn't necessarily the final word.
        self.short_opts = []
        self.long_opts = []
        self.short2long = {}
        self.attr_name = {}
        self.takes_arg = {}

        # And 'option_order' is filled up in 'getopt()'; it records the
        # original order of options (and their values) on the command-line,
        # but expands short options, converts aliases, etc.
        self.option_order = []

    def _build_index(self):
        self.option_index.clear()
        for option in self.option_table:
            self.option_index[option[0]] = option

    def set_option_table(self, option_table):
        self.option_table = option_table
        self._build_index()

    def add_option(self, long_option, short_option=None, help_string=None):
        if long_option in self.option_index:
            raise DistutilsGetoptError(
                "option conflict: already an option '%s'" % long_option
            )
        else:
            option = (long_option, short_option, help_string)
            self.option_table.append(option)
            self.option_index[long_option] = option

    def has_option(self, long_option):
        """Return true if the option table for this parser has an
        option with long name 'long_option'."""
        return long_option in self.option_index

    def get_attr_name(self, long_option):
        """Translate long option name 'long_option' to the form it
        has as an attribute of some object: ie., translate hyphens
        to underscores."""
        return long_option.translate(longopt_xlate)

    def _check_alias_dict(self, aliases, what):
        assert isinstance(aliases, dict)
        for alias, opt in aliases.items():
            if alias not in self.option_index:
                raise DistutilsGetoptError(
                    ("invalid %s '%s': " "option '%s' not defined")
                    % (what, alias, alias)
                )
            if opt not in self.option_index:
                raise DistutilsGetoptError(
                    ("invalid %s '%s': " "aliased option '%s' not defined")
                    % (what, alias, opt)
                )

    def set_aliases(self, alias):
        """Set the aliases for this option parser."""
        self._check_alias_dict(alias, "alias")
        self.alias = alias

    def set_negative_aliases(self, negative_alias):
        """Set the negative aliases for this option parser.
        'negative_alias' should be a dictionary mapping option names to
        option names, both the key and value must already be defined
        in the option table."""
        self._check_alias_dict(negative_alias, "negative alias")
        self.negative_alias = negative_alias

    def _grok_option_table(self):  # noqa: C901
        """Populate the various data structures that keep tabs on the
        option table.  Called by 'getopt()' before it can do anything
        worthwhile.
        """
        self.long_opts = []
        self.short_opts = []
        self.short2long.clear()
        self.repeat = {}

        for option in self.option_table:
            if len(option) == 3:
                long, short, help = option
                repeat = 0
            elif len(option) == 4:
                long, short, help, repeat = option
            else:
                # the option table is part of the code, so simply
                # assert that it is correct
                raise ValueError("invalid option tuple: {!r}".format(option))

            # Type- and value-check the option names
            if not isinstance(long, str) or len(long) < 2:
                raise DistutilsGetoptError(
                    ("invalid long option '%s': " "must be a string of length >= 2")
                    % long
                )

            if not ((short is None) or (isinstance(short, str) and len(short) == 1)):
                raise DistutilsGetoptError(
                    "invalid short option '%s': "
                    "must a single character or None" % short
                )

            self.repeat[long] = repeat
            self.long_opts.append(long)

            if long[-1] == '=':  # option takes an argument?
                if short:
                    short = short + ':'
                long = long[0:-1]
                self.takes_arg[long] = 1
            else:
                # Is option is a "negative alias" for some other option (eg.
                # "quiet" == "!verbose")?
                alias_to = self.negative_alias.get(long)
                if alias_to is not None:
                    if self.takes_arg[alias_to]:
                        raise DistutilsGetoptError(
                            "invalid negative alias '%s': "
                            "aliased option '%s' takes a value" % (long, alias_to)
                        )

                    self.long_opts[-1] = long  # XXX redundant?!
                self.takes_arg[long] = 0

            # If this is an alias option, make sure its "takes arg" flag is
            # the same as the option it's aliased to.
            alias_to = self.alias.get(long)
            if alias_to is not None:
                if self.takes_arg[long] != self.takes_arg[alias_to]:
                    raise DistutilsGetoptError(
                        "invalid alias '%s': inconsistent with "
                        "aliased option '%s' (one of them takes a value, "
                        "the other doesn't" % (long, alias_to)
                    )

            # Now enforce some bondage on the long option name, so we can
            # later translate it to an attribute name on some object.  Have
            # to do this a bit late to make sure we've removed any trailing
            # '='.
            if not longopt_re.match(long):
                raise DistutilsGetoptError(
                    "invalid long option name '%s' "
                    "(must be letters, numbers, hyphens only" % long
                )

            self.attr_name[long] = self.get_attr_name(long)
            if short:
                self.short_opts.append(short)
                self.short2long[short[0]] = long

    def getopt(self, args=None, object=None):  # noqa: C901
        """Parse command-line options in args. Store as attributes on object.

        If 'args' is None or not supplied, uses 'sys.argv[1:]'.  If
        'object' is None or not supplied, creates a new OptionDummy
        object, stores option values there, and returns a tuple (args,
        object).  If 'object' is supplied, it is modified in place and
        'getopt()' just returns 'args'; in both cases, the returned
        'args' is a modified copy of the passed-in 'args' list, which
        is left untouched.
        """
        if args is None:
            args = sys.argv[1:]
        if object is None:
            object = OptionDummy()
            created_object = True
        else:
            created_object = False

        self._grok_option_table()

        short_opts = ' '.join(self.short_opts)
        try:
            opts, args = getopt.getopt(args, short_opts, self.long_opts)
        except getopt.error as msg:
            raise DistutilsArgError(msg)

        for opt, val in opts:
            if len(opt) == 2 and opt[0] == '-':  # it's a short option
                opt = self.short2long[opt[1]]
            else:
                assert len(opt) > 2 and opt[:2] == '--'
                opt = opt[2:]

            alias = self.alias.get(opt)
            if alias:
                opt = alias

            if not self.takes_arg[opt]:  # boolean option?
                assert val == '', "boolean option can't have value"
                alias = self.negative_alias.get(opt)
                if alias:
                    opt = alias
                    val = 0
                else:
                    val = 1

            attr = self.attr_name[opt]
            # The only repeating option at the moment is 'verbose'.
            # It has a negative option -q quiet, which should set verbose = 0.
            if val and self.repeat.get(attr) is not None:
                val = getattr(object, attr, 0) + 1
            setattr(object, attr, val)
            self.option_order.append((opt, val))

        # for opts
        if created_object:
            return args, object
        else:
            return args

    def get_option_order(self):
        """Returns the list of (option, value) tuples processed by the
        previous run of 'getopt()'.  Raises RuntimeError if
        'getopt()' hasn't been called yet.
        """
        if self.option_order is None:
            raise RuntimeError("'getopt()' hasn't been called yet")
        else:
            return self.option_order

    def generate_help(self, header=None):  # noqa: C901
        """Generate help text (a list of strings, one per suggested line of
        output) from the option table for this FancyGetopt object.
        """
        # Blithely assume the option table is good: probably wouldn't call
        # 'generate_help()' unless you've already called 'getopt()'.

        # First pass: determine maximum length of long option names
        max_opt = 0
        for option in self.option_table:
            long = option[0]
            short = option[1]
            ell = len(long)
            if long[-1] == '=':
                ell = ell - 1
            if short is not None:
                ell = ell + 5  # " (-x)" where short == 'x'
            if ell > max_opt:
                max_opt = ell

        opt_width = max_opt + 2 + 2 + 2  # room for indent + dashes + gutter

        # Typical help block looks like this:
        #   --foo       controls foonabulation
        # Help block for longest option looks like this:
        #   --flimflam  set the flim-flam level
        # and with wrapped text:
        #   --flimflam  set the flim-flam level (must be between
        #               0 and 100, except on Tuesdays)
        # Options with short names will have the short name shown (but
        # it doesn't contribute to max_opt):
        #   --foo (-f)  controls foonabulation
        # If adding the short option would make the left column too wide,
        # we push the explanation off to the next line
        #   --flimflam (-l)
        #               set the flim-flam level
        # Important parameters:
        #   - 2 spaces before option block start lines
        #   - 2 dashes for each long option name
        #   - min. 2 spaces between option and explanation (gutter)
        #   - 5 characters (incl. space) for short option name

        # Now generate lines of help text.  (If 80 columns were good enough
        # for Jesus, then 78 columns are good enough for me!)
        line_width = 78
        text_width = line_width - opt_width
        big_indent = ' ' * opt_width
        if header:
            lines = [header]
        else:
            lines = ['Option summary:']

        for option in self.option_table:
            long, short, help = option[:3]
            text = wrap_text(help, text_width)
            if long[-1] == '=':
                long = long[0:-1]

            # Case 1: no short option at all (makes life easy)
            if short is None:
                if text:
                    lines.append("  --%-*s  %s" % (max_opt, long, text[0]))
                else:
                    lines.append("  --%-*s  " % (max_opt, long))

            # Case 2: we have a short option, so we have to include it
            # just after the long option
            else:
                opt_names = "{} (-{})".format(long, short)
                if text:
                    lines.append("  --%-*s  %s" % (max_opt, opt_names, text[0]))
                else:
                    lines.append("  --%-*s" % opt_names)

            for ell in text[1:]:
                lines.append(big_indent + ell)
        return lines

    def print_help(self, header=None, file=None):
        if file is None:
            file = sys.stdout
        for line in self.generate_help(header):
            file.write(line + "\n")


def fancy_getopt(options, negative_opt, object, args):
    parser = FancyGetopt(options)
    parser.set_negative_aliases(negative_opt)
    return parser.getopt(args, object)


WS_TRANS = {ord(_wschar): ' ' for _wschar in string.whitespace}


def wrap_text(text, width):
    """wrap_text(text : string, width : int) -> [string]

    Split 'text' into multiple lines of no more than 'width' characters
    each, and return the list of strings that results.
    """
    if text is None:
        return []
    if len(text) <= width:
        return [text]

    text = text.expandtabs()
    text = text.translate(WS_TRANS)
    chunks = re.split(r'( +|-+)', text)
    chunks = [ch for ch in chunks if ch]  # ' - ' results in empty strings
    lines = []

    while chunks:
        cur_line = []  # list of chunks (to-be-joined)
        cur_len = 0  # length of current line

        while chunks:
            ell = len(chunks[0])
            if cur_len + ell <= width:  # can squeeze (at least) this chunk in
                cur_line.append(chunks[0])
                del chunks[0]
                cur_len = cur_len + ell
            else:  # this line is full
                # drop last chunk if all space
                if cur_line and cur_line[-1][0] == ' ':
                    del cur_line[-1]
                break

        if chunks:  # any chunks left to process?
            # if the current line is still empty, then we had a single
            # chunk that's too big too fit on a line -- so we break
            # down and break it up at the line width
            if cur_len == 0:
                cur_line.append(chunks[0][0:width])
                chunks[0] = chunks[0][width:]

            # all-whitespace chunks at the end of a line can be discarded
            # (and we know from the re.split above that if a chunk has
            # *any* whitespace, it is *all* whitespace)
            if chunks[0][0] == ' ':
                del chunks[0]

        # and store this line in the list-of-all-lines -- as a single
        # string, of course!
        lines.append(''.join(cur_line))

    return lines


def translate_longopt(opt):
    """Convert a long option name to a valid Python identifier by
    changing "-" to "_".
    """
    return opt.translate(longopt_xlate)


class OptionDummy:
    """Dummy class just used as a place to hold command-line option
    values as instance attributes."""

    def __init__(self, options=[]):
        """Create a new OptionDummy instance.  The attributes listed in
        'options' will be initialized to None."""
        for opt in options:
            setattr(self, opt, None)


if __name__ == "__main__":
    text = """\
Tra-la-la, supercalifragilisticexpialidocious.
How *do* you spell that odd word, anyways?
(Someone ask Mary -- she'll know [or she'll
say, "How should I know?"].)"""

    for w in (10, 20, 30, 40):
        print("width: %d" % w)
        print("\n".join(wrap_text(text, w)))
        print()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/file_util.py0000644000175100001730000002002414467657412022402 0ustar00runnerdocker"""distutils.file_util

Utility functions for operating on single files.
"""

import os
from .errors import DistutilsFileError
from ._log import log

# for generating verbose output in 'copy_file()'
_copy_action = {None: 'copying', 'hard': 'hard linking', 'sym': 'symbolically linking'}


def _copy_file_contents(src, dst, buffer_size=16 * 1024):  # noqa: C901
    """Copy the file 'src' to 'dst'; both must be filenames.  Any error
    opening either file, reading from 'src', or writing to 'dst', raises
    DistutilsFileError.  Data is read/written in chunks of 'buffer_size'
    bytes (default 16k).  No attempt is made to handle anything apart from
    regular files.
    """
    # Stolen from shutil module in the standard library, but with
    # custom error-handling added.
    fsrc = None
    fdst = None
    try:
        try:
            fsrc = open(src, 'rb')
        except OSError as e:
            raise DistutilsFileError("could not open '{}': {}".format(src, e.strerror))

        if os.path.exists(dst):
            try:
                os.unlink(dst)
            except OSError as e:
                raise DistutilsFileError(
                    "could not delete '{}': {}".format(dst, e.strerror)
                )

        try:
            fdst = open(dst, 'wb')
        except OSError as e:
            raise DistutilsFileError(
                "could not create '{}': {}".format(dst, e.strerror)
            )

        while True:
            try:
                buf = fsrc.read(buffer_size)
            except OSError as e:
                raise DistutilsFileError(
                    "could not read from '{}': {}".format(src, e.strerror)
                )

            if not buf:
                break

            try:
                fdst.write(buf)
            except OSError as e:
                raise DistutilsFileError(
                    "could not write to '{}': {}".format(dst, e.strerror)
                )
    finally:
        if fdst:
            fdst.close()
        if fsrc:
            fsrc.close()


def copy_file(  # noqa: C901
    src,
    dst,
    preserve_mode=1,
    preserve_times=1,
    update=0,
    link=None,
    verbose=1,
    dry_run=0,
):
    """Copy a file 'src' to 'dst'.  If 'dst' is a directory, then 'src' is
    copied there with the same name; otherwise, it must be a filename.  (If
    the file exists, it will be ruthlessly clobbered.)  If 'preserve_mode'
    is true (the default), the file's mode (type and permission bits, or
    whatever is analogous on the current platform) is copied.  If
    'preserve_times' is true (the default), the last-modified and
    last-access times are copied as well.  If 'update' is true, 'src' will
    only be copied if 'dst' does not exist, or if 'dst' does exist but is
    older than 'src'.

    'link' allows you to make hard links (os.link) or symbolic links
    (os.symlink) instead of copying: set it to "hard" or "sym"; if it is
    None (the default), files are copied.  Don't set 'link' on systems that
    don't support it: 'copy_file()' doesn't check if hard or symbolic
    linking is available. If hardlink fails, falls back to
    _copy_file_contents().

    Under Mac OS, uses the native file copy function in macostools; on
    other systems, uses '_copy_file_contents()' to copy file contents.

    Return a tuple (dest_name, copied): 'dest_name' is the actual name of
    the output file, and 'copied' is true if the file was copied (or would
    have been copied, if 'dry_run' true).
    """
    # XXX if the destination file already exists, we clobber it if
    # copying, but blow up if linking.  Hmmm.  And I don't know what
    # macostools.copyfile() does.  Should definitely be consistent, and
    # should probably blow up if destination exists and we would be
    # changing it (ie. it's not already a hard/soft link to src OR
    # (not update) and (src newer than dst).

    from distutils.dep_util import newer
    from stat import ST_ATIME, ST_MTIME, ST_MODE, S_IMODE

    if not os.path.isfile(src):
        raise DistutilsFileError(
            "can't copy '%s': doesn't exist or not a regular file" % src
        )

    if os.path.isdir(dst):
        dir = dst
        dst = os.path.join(dst, os.path.basename(src))
    else:
        dir = os.path.dirname(dst)

    if update and not newer(src, dst):
        if verbose >= 1:
            log.debug("not copying %s (output up-to-date)", src)
        return (dst, 0)

    try:
        action = _copy_action[link]
    except KeyError:
        raise ValueError("invalid value '%s' for 'link' argument" % link)

    if verbose >= 1:
        if os.path.basename(dst) == os.path.basename(src):
            log.info("%s %s -> %s", action, src, dir)
        else:
            log.info("%s %s -> %s", action, src, dst)

    if dry_run:
        return (dst, 1)

    # If linking (hard or symbolic), use the appropriate system call
    # (Unix only, of course, but that's the caller's responsibility)
    elif link == 'hard':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            try:
                os.link(src, dst)
                return (dst, 1)
            except OSError:
                # If hard linking fails, fall back on copying file
                # (some special filesystems don't support hard linking
                #  even under Unix, see issue #8876).
                pass
    elif link == 'sym':
        if not (os.path.exists(dst) and os.path.samefile(src, dst)):
            os.symlink(src, dst)
            return (dst, 1)

    # Otherwise (non-Mac, not linking), copy the file contents and
    # (optionally) copy the times and mode.
    _copy_file_contents(src, dst)
    if preserve_mode or preserve_times:
        st = os.stat(src)

        # According to David Ascher , utime() should be done
        # before chmod() (at least under NT).
        if preserve_times:
            os.utime(dst, (st[ST_ATIME], st[ST_MTIME]))
        if preserve_mode:
            os.chmod(dst, S_IMODE(st[ST_MODE]))

    return (dst, 1)


# XXX I suspect this is Unix-specific -- need porting help!
def move_file(src, dst, verbose=1, dry_run=0):  # noqa: C901
    """Move a file 'src' to 'dst'.  If 'dst' is a directory, the file will
    be moved into it with the same name; otherwise, 'src' is just renamed
    to 'dst'.  Return the new full name of the file.

    Handles cross-device moves on Unix using 'copy_file()'.  What about
    other systems???
    """
    from os.path import exists, isfile, isdir, basename, dirname
    import errno

    if verbose >= 1:
        log.info("moving %s -> %s", src, dst)

    if dry_run:
        return dst

    if not isfile(src):
        raise DistutilsFileError("can't move '%s': not a regular file" % src)

    if isdir(dst):
        dst = os.path.join(dst, basename(src))
    elif exists(dst):
        raise DistutilsFileError(
            "can't move '{}': destination '{}' already exists".format(src, dst)
        )

    if not isdir(dirname(dst)):
        raise DistutilsFileError(
            "can't move '{}': destination '{}' not a valid path".format(src, dst)
        )

    copy_it = False
    try:
        os.rename(src, dst)
    except OSError as e:
        (num, msg) = e.args
        if num == errno.EXDEV:
            copy_it = True
        else:
            raise DistutilsFileError(
                "couldn't move '{}' to '{}': {}".format(src, dst, msg)
            )

    if copy_it:
        copy_file(src, dst, verbose=verbose)
        try:
            os.unlink(src)
        except OSError as e:
            (num, msg) = e.args
            try:
                os.unlink(dst)
            except OSError:
                pass
            raise DistutilsFileError(
                "couldn't move '%s' to '%s' by copy/delete: "
                "delete '%s' failed: %s" % (src, dst, src, msg)
            )
    return dst


def write_file(filename, contents):
    """Create a file with the specified name and write 'contents' (a
    sequence of strings without line terminators) to it.
    """
    f = open(filename, "w")
    try:
        for line in contents:
            f.write(line + "\n")
    finally:
        f.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/filelist.py0000644000175100001730000003262314467657412022251 0ustar00runnerdocker"""distutils.filelist

Provides the FileList class, used for poking about the filesystem
and building lists of files.
"""

import os
import re
import fnmatch
import functools

from .util import convert_path
from .errors import DistutilsTemplateError, DistutilsInternalError
from ._log import log


class FileList:
    """A list of files built by on exploring the filesystem and filtered by
    applying various patterns to what we find there.

    Instance attributes:
      dir
        directory from which files will be taken -- only used if
        'allfiles' not supplied to constructor
      files
        list of filenames currently being built/filtered/manipulated
      allfiles
        complete list of files under consideration (ie. without any
        filtering applied)
    """

    def __init__(self, warn=None, debug_print=None):
        # ignore argument to FileList, but keep them for backwards
        # compatibility
        self.allfiles = None
        self.files = []

    def set_allfiles(self, allfiles):
        self.allfiles = allfiles

    def findall(self, dir=os.curdir):
        self.allfiles = findall(dir)

    def debug_print(self, msg):
        """Print 'msg' to stdout if the global DEBUG (taken from the
        DISTUTILS_DEBUG environment variable) flag is true.
        """
        from distutils.debug import DEBUG

        if DEBUG:
            print(msg)

    # Collection methods

    def append(self, item):
        self.files.append(item)

    def extend(self, items):
        self.files.extend(items)

    def sort(self):
        # Not a strict lexical sort!
        sortable_files = sorted(map(os.path.split, self.files))
        self.files = []
        for sort_tuple in sortable_files:
            self.files.append(os.path.join(*sort_tuple))

    # Other miscellaneous utility methods

    def remove_duplicates(self):
        # Assumes list has been sorted!
        for i in range(len(self.files) - 1, 0, -1):
            if self.files[i] == self.files[i - 1]:
                del self.files[i]

    # "File template" methods

    def _parse_template_line(self, line):
        words = line.split()
        action = words[0]

        patterns = dir = dir_pattern = None

        if action in ('include', 'exclude', 'global-include', 'global-exclude'):
            if len(words) < 2:
                raise DistutilsTemplateError(
                    "'%s' expects   ..." % action
                )
            patterns = [convert_path(w) for w in words[1:]]
        elif action in ('recursive-include', 'recursive-exclude'):
            if len(words) < 3:
                raise DistutilsTemplateError(
                    "'%s' expects 
   ..." % action
                )
            dir = convert_path(words[1])
            patterns = [convert_path(w) for w in words[2:]]
        elif action in ('graft', 'prune'):
            if len(words) != 2:
                raise DistutilsTemplateError(
                    "'%s' expects a single " % action
                )
            dir_pattern = convert_path(words[1])
        else:
            raise DistutilsTemplateError("unknown action '%s'" % action)

        return (action, patterns, dir, dir_pattern)

    def process_template_line(self, line):  # noqa: C901
        # Parse the line: split it up, make sure the right number of words
        # is there, and return the relevant words.  'action' is always
        # defined: it's the first word of the line.  Which of the other
        # three are defined depends on the action; it'll be either
        # patterns, (dir and patterns), or (dir_pattern).
        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)

        # OK, now we know that the action is valid and we have the
        # right number of words on the line for that action -- so we
        # can proceed with minimal error-checking.
        if action == 'include':
            self.debug_print("include " + ' '.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=1):
                    log.warning("warning: no files found matching '%s'", pattern)

        elif action == 'exclude':
            self.debug_print("exclude " + ' '.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=1):
                    log.warning(
                        (
                            "warning: no previously-included files "
                            "found matching '%s'"
                        ),
                        pattern,
                    )

        elif action == 'global-include':
            self.debug_print("global-include " + ' '.join(patterns))
            for pattern in patterns:
                if not self.include_pattern(pattern, anchor=0):
                    log.warning(
                        (
                            "warning: no files found matching '%s' "
                            "anywhere in distribution"
                        ),
                        pattern,
                    )

        elif action == 'global-exclude':
            self.debug_print("global-exclude " + ' '.join(patterns))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, anchor=0):
                    log.warning(
                        (
                            "warning: no previously-included files matching "
                            "'%s' found anywhere in distribution"
                        ),
                        pattern,
                    )

        elif action == 'recursive-include':
            self.debug_print("recursive-include {} {}".format(dir, ' '.join(patterns)))
            for pattern in patterns:
                if not self.include_pattern(pattern, prefix=dir):
                    msg = (
                        "warning: no files found matching '%s' " "under directory '%s'"
                    )
                    log.warning(msg, pattern, dir)

        elif action == 'recursive-exclude':
            self.debug_print("recursive-exclude {} {}".format(dir, ' '.join(patterns)))
            for pattern in patterns:
                if not self.exclude_pattern(pattern, prefix=dir):
                    log.warning(
                        (
                            "warning: no previously-included files matching "
                            "'%s' found under directory '%s'"
                        ),
                        pattern,
                        dir,
                    )

        elif action == 'graft':
            self.debug_print("graft " + dir_pattern)
            if not self.include_pattern(None, prefix=dir_pattern):
                log.warning("warning: no directories found matching '%s'", dir_pattern)

        elif action == 'prune':
            self.debug_print("prune " + dir_pattern)
            if not self.exclude_pattern(None, prefix=dir_pattern):
                log.warning(
                    ("no previously-included directories found " "matching '%s'"),
                    dir_pattern,
                )
        else:
            raise DistutilsInternalError(
                "this cannot happen: invalid action '%s'" % action
            )

    # Filtering/selection methods

    def include_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
        """Select strings (presumably filenames) from 'self.files' that
        match 'pattern', a Unix-style wildcard (glob) pattern.  Patterns
        are not quite the same as implemented by the 'fnmatch' module: '*'
        and '?'  match non-special characters, where "special" is platform-
        dependent: slash on Unix; colon, slash, and backslash on
        DOS/Windows; and colon on Mac OS.

        If 'anchor' is true (the default), then the pattern match is more
        stringent: "*.py" will match "foo.py" but not "foo/bar.py".  If
        'anchor' is false, both of these will match.

        If 'prefix' is supplied, then only filenames starting with 'prefix'
        (itself a pattern) and ending with 'pattern', with anything in between
        them, will match.  'anchor' is ignored in this case.

        If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and
        'pattern' is assumed to be either a string containing a regex or a
        regex object -- no translation is done, the regex is just compiled
        and used as-is.

        Selected strings will be added to self.files.

        Return True if files are found, False otherwise.
        """
        # XXX docstring lying about what the special chars are?
        files_found = False
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print("include_pattern: applying regex r'%s'" % pattern_re.pattern)

        # delayed loading of allfiles list
        if self.allfiles is None:
            self.findall()

        for name in self.allfiles:
            if pattern_re.search(name):
                self.debug_print(" adding " + name)
                self.files.append(name)
                files_found = True
        return files_found

    def exclude_pattern(self, pattern, anchor=1, prefix=None, is_regex=0):
        """Remove strings (presumably filenames) from 'files' that match
        'pattern'.  Other parameters are the same as for
        'include_pattern()', above.
        The list 'self.files' is modified in place.
        Return True if files are found, False otherwise.
        """
        files_found = False
        pattern_re = translate_pattern(pattern, anchor, prefix, is_regex)
        self.debug_print("exclude_pattern: applying regex r'%s'" % pattern_re.pattern)
        for i in range(len(self.files) - 1, -1, -1):
            if pattern_re.search(self.files[i]):
                self.debug_print(" removing " + self.files[i])
                del self.files[i]
                files_found = True
        return files_found


# Utility functions


def _find_all_simple(path):
    """
    Find all files under 'path'
    """
    all_unique = _UniqueDirs.filter(os.walk(path, followlinks=True))
    results = (
        os.path.join(base, file) for base, dirs, files in all_unique for file in files
    )
    return filter(os.path.isfile, results)


class _UniqueDirs(set):
    """
    Exclude previously-seen dirs from walk results,
    avoiding infinite recursion.
    Ref https://bugs.python.org/issue44497.
    """

    def __call__(self, walk_item):
        """
        Given an item from an os.walk result, determine
        if the item represents a unique dir for this instance
        and if not, prevent further traversal.
        """
        base, dirs, files = walk_item
        stat = os.stat(base)
        candidate = stat.st_dev, stat.st_ino
        found = candidate in self
        if found:
            del dirs[:]
        self.add(candidate)
        return not found

    @classmethod
    def filter(cls, items):
        return filter(cls(), items)


def findall(dir=os.curdir):
    """
    Find all files under 'dir' and return the list of full filenames.
    Unless dir is '.', return full filenames with dir prepended.
    """
    files = _find_all_simple(dir)
    if dir == os.curdir:
        make_rel = functools.partial(os.path.relpath, start=dir)
        files = map(make_rel, files)
    return list(files)


def glob_to_re(pattern):
    """Translate a shell-like glob pattern to a regular expression; return
    a string containing the regex.  Differs from 'fnmatch.translate()' in
    that '*' does not match "special characters" (which are
    platform-specific).
    """
    pattern_re = fnmatch.translate(pattern)

    # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which
    # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix,
    # and by extension they shouldn't match such "special characters" under
    # any OS.  So change all non-escaped dots in the RE to match any
    # character except the special characters (currently: just os.sep).
    sep = os.sep
    if os.sep == '\\':
        # we're using a regex to manipulate a regex, so we need
        # to escape the backslash twice
        sep = r'\\\\'
    escaped = r'\1[^%s]' % sep
    pattern_re = re.sub(r'((?= 2:
        set_threshold(logging.DEBUG)


class Log(logging.Logger):
    """distutils.log.Log is deprecated, please use an alternative from `logging`."""

    def __init__(self, threshold=WARN):
        warnings.warn(Log.__doc__)  # avoid DeprecationWarning to ensure warn is shown
        super().__init__(__name__, level=threshold)

    @property
    def threshold(self):
        return self.level

    @threshold.setter
    def threshold(self, level):
        self.setLevel(level)

    warn = logging.Logger.warning
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/msvc9compiler.py0000644000175100001730000007275414467657412023243 0ustar00runnerdocker"""distutils.msvc9compiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio 2008.

The module is compatible with VS 2005 and VS 2008. You can find legacy support
for older versions of VS in distutils.msvccompiler.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)
# ported to VS2005 and VS 2008 by Christian Heimes

import os
import subprocess
import sys
import re
import warnings

from .errors import (
    DistutilsExecError,
    DistutilsPlatformError,
    CompileError,
    LibError,
    LinkError,
)
from .ccompiler import CCompiler, gen_lib_options
from ._log import log
from .util import get_platform

import winreg

warnings.warn(
    "msvc9compiler is deprecated and slated to be removed "
    "in the future. Please discontinue use or file an issue "
    "with pypa/distutils describing your use case.",
    DeprecationWarning,
)

RegOpenKeyEx = winreg.OpenKeyEx
RegEnumKey = winreg.EnumKey
RegEnumValue = winreg.EnumValue
RegError = winreg.error

HKEYS = (
    winreg.HKEY_USERS,
    winreg.HKEY_CURRENT_USER,
    winreg.HKEY_LOCAL_MACHINE,
    winreg.HKEY_CLASSES_ROOT,
)

NATIVE_WIN64 = sys.platform == 'win32' and sys.maxsize > 2**32
if NATIVE_WIN64:
    # Visual C++ is a 32-bit application, so we need to look in
    # the corresponding registry branch, if we're running a
    # 64-bit Python on Win64
    VS_BASE = r"Software\Wow6432Node\Microsoft\VisualStudio\%0.1f"
    WINSDK_BASE = r"Software\Wow6432Node\Microsoft\Microsoft SDKs\Windows"
    NET_BASE = r"Software\Wow6432Node\Microsoft\.NETFramework"
else:
    VS_BASE = r"Software\Microsoft\VisualStudio\%0.1f"
    WINSDK_BASE = r"Software\Microsoft\Microsoft SDKs\Windows"
    NET_BASE = r"Software\Microsoft\.NETFramework"

# A map keyed by get_platform() return values to values accepted by
# 'vcvarsall.bat'.  Note a cross-compile may combine these (eg, 'x86_amd64' is
# the param to cross-compile on x86 targeting amd64.)
PLAT_TO_VCVARS = {
    'win32': 'x86',
    'win-amd64': 'amd64',
}


class Reg:
    """Helper class to read values from the registry"""

    def get_value(cls, path, key):
        for base in HKEYS:
            d = cls.read_values(base, path)
            if d and key in d:
                return d[key]
        raise KeyError(key)

    get_value = classmethod(get_value)

    def read_keys(cls, base, key):
        """Return list of registry keys."""
        try:
            handle = RegOpenKeyEx(base, key)
        except RegError:
            return None
        L = []
        i = 0
        while True:
            try:
                k = RegEnumKey(handle, i)
            except RegError:
                break
            L.append(k)
            i += 1
        return L

    read_keys = classmethod(read_keys)

    def read_values(cls, base, key):
        """Return dict of registry keys and values.

        All names are converted to lowercase.
        """
        try:
            handle = RegOpenKeyEx(base, key)
        except RegError:
            return None
        d = {}
        i = 0
        while True:
            try:
                name, value, type = RegEnumValue(handle, i)
            except RegError:
                break
            name = name.lower()
            d[cls.convert_mbcs(name)] = cls.convert_mbcs(value)
            i += 1
        return d

    read_values = classmethod(read_values)

    def convert_mbcs(s):
        dec = getattr(s, "decode", None)
        if dec is not None:
            try:
                s = dec("mbcs")
            except UnicodeError:
                pass
        return s

    convert_mbcs = staticmethod(convert_mbcs)


class MacroExpander:
    def __init__(self, version):
        self.macros = {}
        self.vsbase = VS_BASE % version
        self.load_macros(version)

    def set_macro(self, macro, path, key):
        self.macros["$(%s)" % macro] = Reg.get_value(path, key)

    def load_macros(self, version):
        self.set_macro("VCInstallDir", self.vsbase + r"\Setup\VC", "productdir")
        self.set_macro("VSInstallDir", self.vsbase + r"\Setup\VS", "productdir")
        self.set_macro("FrameworkDir", NET_BASE, "installroot")
        try:
            if version >= 8.0:
                self.set_macro("FrameworkSDKDir", NET_BASE, "sdkinstallrootv2.0")
            else:
                raise KeyError("sdkinstallrootv2.0")
        except KeyError:
            raise DistutilsPlatformError(
                """Python was built with Visual Studio 2008;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2008 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py."""
            )

        if version >= 9.0:
            self.set_macro("FrameworkVersion", self.vsbase, "clr version")
            self.set_macro("WindowsSdkDir", WINSDK_BASE, "currentinstallfolder")
        else:
            p = r"Software\Microsoft\NET Framework Setup\Product"
            for base in HKEYS:
                try:
                    h = RegOpenKeyEx(base, p)
                except RegError:
                    continue
                key = RegEnumKey(h, 0)
                d = Reg.get_value(base, r"{}\{}".format(p, key))
                self.macros["$(FrameworkVersion)"] = d["version"]

    def sub(self, s):
        for k, v in self.macros.items():
            s = s.replace(k, v)
        return s


def get_build_version():
    """Return the version of MSVC that was used to build Python.

    For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    """
    prefix = "MSC v."
    i = sys.version.find(prefix)
    if i == -1:
        return 6
    i = i + len(prefix)
    s, rest = sys.version[i:].split(" ", 1)
    majorVersion = int(s[:-2]) - 6
    if majorVersion >= 13:
        # v13 was skipped and should be v14
        majorVersion += 1
    minorVersion = int(s[2:3]) / 10.0
    # I don't think paths are affected by minor version in version 6
    if majorVersion == 6:
        minorVersion = 0
    if majorVersion >= 6:
        return majorVersion + minorVersion
    # else we don't know what version of the compiler this is
    return None


def normalize_and_reduce_paths(paths):
    """Return a list of normalized paths with duplicates removed.

    The current order of paths is maintained.
    """
    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
    reduced_paths = []
    for p in paths:
        np = os.path.normpath(p)
        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
        if np not in reduced_paths:
            reduced_paths.append(np)
    return reduced_paths


def removeDuplicates(variable):
    """Remove duplicate values of an environment variable."""
    oldList = variable.split(os.pathsep)
    newList = []
    for i in oldList:
        if i not in newList:
            newList.append(i)
    newVariable = os.pathsep.join(newList)
    return newVariable


def find_vcvarsall(version):
    """Find the vcvarsall.bat file

    At first it tries to find the productdir of VS 2008 in the registry. If
    that fails it falls back to the VS90COMNTOOLS env var.
    """
    vsbase = VS_BASE % version
    try:
        productdir = Reg.get_value(r"%s\Setup\VC" % vsbase, "productdir")
    except KeyError:
        log.debug("Unable to find productdir in registry")
        productdir = None

    if not productdir or not os.path.isdir(productdir):
        toolskey = "VS%0.f0COMNTOOLS" % version
        toolsdir = os.environ.get(toolskey, None)

        if toolsdir and os.path.isdir(toolsdir):
            productdir = os.path.join(toolsdir, os.pardir, os.pardir, "VC")
            productdir = os.path.abspath(productdir)
            if not os.path.isdir(productdir):
                log.debug("%s is not a valid directory" % productdir)
                return None
        else:
            log.debug("Env var %s is not set or invalid" % toolskey)
    if not productdir:
        log.debug("No productdir found")
        return None
    vcvarsall = os.path.join(productdir, "vcvarsall.bat")
    if os.path.isfile(vcvarsall):
        return vcvarsall
    log.debug("Unable to find vcvarsall.bat")
    return None


def query_vcvarsall(version, arch="x86"):
    """Launch vcvarsall.bat and read the settings from its environment"""
    vcvarsall = find_vcvarsall(version)
    interesting = {"include", "lib", "libpath", "path"}
    result = {}

    if vcvarsall is None:
        raise DistutilsPlatformError("Unable to find vcvarsall.bat")
    log.debug("Calling 'vcvarsall.bat %s' (version=%s)", arch, version)
    popen = subprocess.Popen(
        '"{}" {} & set'.format(vcvarsall, arch),
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
    )
    try:
        stdout, stderr = popen.communicate()
        if popen.wait() != 0:
            raise DistutilsPlatformError(stderr.decode("mbcs"))

        stdout = stdout.decode("mbcs")
        for line in stdout.split("\n"):
            line = Reg.convert_mbcs(line)
            if '=' not in line:
                continue
            line = line.strip()
            key, value = line.split('=', 1)
            key = key.lower()
            if key in interesting:
                if value.endswith(os.pathsep):
                    value = value[:-1]
                result[key] = removeDuplicates(value)

    finally:
        popen.stdout.close()
        popen.stderr.close()

    if len(result) != len(interesting):
        raise ValueError(str(list(result.keys())))

    return result


# More globals
VERSION = get_build_version()
# MACROS = MacroExpander(VERSION)


class MSVCCompiler(CCompiler):
    """Concrete class that implements an interface to Microsoft Visual C++,
    as defined by the CCompiler abstract class."""

    compiler_type = 'msvc'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']
    _rc_extensions = ['.rc']
    _mc_extensions = ['.mc']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = _c_extensions + _cpp_extensions + _rc_extensions + _mc_extensions
    res_extension = '.res'
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

    def __init__(self, verbose=0, dry_run=0, force=0):
        super().__init__(verbose, dry_run, force)
        self.__version = VERSION
        self.__root = r"Software\Microsoft\VisualStudio"
        # self.__macros = MACROS
        self.__paths = []
        # target platform (.plat_name is consistent with 'bdist')
        self.plat_name = None
        self.__arch = None  # deprecated name
        self.initialized = False

    def initialize(self, plat_name=None):  # noqa: C901
        # multi-init means we would need to check platform same each time...
        assert not self.initialized, "don't init multiple times"
        if self.__version < 8.0:
            raise DistutilsPlatformError(
                "VC %0.1f is not supported by this module" % self.__version
            )
        if plat_name is None:
            plat_name = get_platform()
        # sanity check for platforms to prevent obscure errors later.
        ok_plats = 'win32', 'win-amd64'
        if plat_name not in ok_plats:
            raise DistutilsPlatformError(
                "--plat-name must be one of {}".format(ok_plats)
            )

        if (
            "DISTUTILS_USE_SDK" in os.environ
            and "MSSdk" in os.environ
            and self.find_exe("cl.exe")
        ):
            # Assume that the SDK set up everything alright; don't try to be
            # smarter
            self.cc = "cl.exe"
            self.linker = "link.exe"
            self.lib = "lib.exe"
            self.rc = "rc.exe"
            self.mc = "mc.exe"
        else:
            # On x86, 'vcvars32.bat amd64' creates an env that doesn't work;
            # to cross compile, you use 'x86_amd64'.
            # On AMD64, 'vcvars32.bat amd64' is a native build env; to cross
            # compile use 'x86' (ie, it runs the x86 compiler directly)
            if plat_name in (get_platform(), 'win32'):
                # native build or cross-compile to win32
                plat_spec = PLAT_TO_VCVARS[plat_name]
            else:
                # cross compile from win32 -> some 64bit
                plat_spec = (
                    PLAT_TO_VCVARS[get_platform()] + '_' + PLAT_TO_VCVARS[plat_name]
                )

            vc_env = query_vcvarsall(VERSION, plat_spec)

            self.__paths = vc_env['path'].split(os.pathsep)
            os.environ['lib'] = vc_env['lib']
            os.environ['include'] = vc_env['include']

            if len(self.__paths) == 0:
                raise DistutilsPlatformError(
                    "Python was built with %s, "
                    "and extensions need to be built with the same "
                    "version of the compiler, but it isn't installed." % self.__product
                )

            self.cc = self.find_exe("cl.exe")
            self.linker = self.find_exe("link.exe")
            self.lib = self.find_exe("lib.exe")
            self.rc = self.find_exe("rc.exe")  # resource compiler
            self.mc = self.find_exe("mc.exe")  # message compiler
            # self.set_path_env_var('lib')
            # self.set_path_env_var('include')

        # extend the MSVC path with the current path
        try:
            for p in os.environ['path'].split(';'):
                self.__paths.append(p)
        except KeyError:
            pass
        self.__paths = normalize_and_reduce_paths(self.__paths)
        os.environ['path'] = ";".join(self.__paths)

        self.preprocess_options = None
        if self.__arch == "x86":
            self.compile_options = ['/nologo', '/O2', '/MD', '/W3', '/DNDEBUG']
            self.compile_options_debug = [
                '/nologo',
                '/Od',
                '/MDd',
                '/W3',
                '/Z7',
                '/D_DEBUG',
            ]
        else:
            # Win64
            self.compile_options = ['/nologo', '/O2', '/MD', '/W3', '/GS-', '/DNDEBUG']
            self.compile_options_debug = [
                '/nologo',
                '/Od',
                '/MDd',
                '/W3',
                '/GS-',
                '/Z7',
                '/D_DEBUG',
            ]

        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
        if self.__version >= 7:
            self.ldflags_shared_debug = ['/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG']
        self.ldflags_static = ['/nologo']

        self.initialized = True

    # -- Worker methods ------------------------------------------------

    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
        # Copied from ccompiler.py, extended to return .res as 'object'-file
        # for .rc input file
        if output_dir is None:
            output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            (base, ext) = os.path.splitext(src_name)
            base = os.path.splitdrive(base)[1]  # Chop off the drive
            base = base[os.path.isabs(base) :]  # If abs, chop off leading /
            if ext not in self.src_extensions:
                # Better to raise an exception instead of silently continuing
                # and later complain about sources and targets having
                # different lengths
                raise CompileError("Don't know how to compile %s" % src_name)
            if strip_dir:
                base = os.path.basename(base)
            if ext in self._rc_extensions:
                obj_names.append(os.path.join(output_dir, base + self.res_extension))
            elif ext in self._mc_extensions:
                obj_names.append(os.path.join(output_dir, base + self.res_extension))
            else:
                obj_names.append(os.path.join(output_dir, base + self.obj_extension))
        return obj_names

    def compile(  # noqa: C901
        self,
        sources,
        output_dir=None,
        macros=None,
        include_dirs=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        depends=None,
    ):
        if not self.initialized:
            self.initialize()
        compile_info = self._setup_compile(
            output_dir, macros, include_dirs, sources, depends, extra_postargs
        )
        macros, objects, extra_postargs, pp_opts, build = compile_info

        compile_opts = extra_preargs or []
        compile_opts.append('/c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            if debug:
                # pass the full pathname to MSVC in debug mode,
                # this allows the debugger to find the source file
                # without asking the user to browse for it
                src = os.path.abspath(src)

            if ext in self._c_extensions:
                input_opt = "/Tc" + src
            elif ext in self._cpp_extensions:
                input_opt = "/Tp" + src
            elif ext in self._rc_extensions:
                # compile .RC to .RES file
                input_opt = src
                output_opt = "/fo" + obj
                try:
                    self.spawn([self.rc] + pp_opts + [output_opt] + [input_opt])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            elif ext in self._mc_extensions:
                # Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.
                h_dir = os.path.dirname(src)
                rc_dir = os.path.dirname(obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn([self.mc] + ['-h', h_dir, '-r', rc_dir] + [src])
                    base, _ = os.path.splitext(os.path.basename(src))
                    rc_file = os.path.join(rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn([self.rc] + ["/fo" + obj] + [rc_file])

                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            else:
                # how to handle this file?
                raise CompileError(
                    "Don't know how to compile {} to {}".format(src, obj)
                )

            output_opt = "/Fo" + obj
            try:
                self.spawn(
                    [self.cc]
                    + compile_opts
                    + pp_opts
                    + [input_opt, output_opt]
                    + extra_postargs
                )
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects

    def create_static_lib(
        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
    ):
        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname, output_dir=output_dir)

        if self._need_link(objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass  # XXX what goes here?
            try:
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def link(  # noqa: C901
        self,
        target_desc,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
        (libraries, library_dirs, runtime_library_dirs) = fixed_args

        if runtime_library_dirs:
            self.warn(
                "I don't know what to do with 'runtime_library_dirs': "
                + str(runtime_library_dirs)
            )

        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            if target_desc == CCompiler.EXECUTABLE:
                if debug:
                    ldflags = self.ldflags_shared_debug[1:]
                else:
                    ldflags = self.ldflags_shared[1:]
            else:
                if debug:
                    ldflags = self.ldflags_shared_debug
                else:
                    ldflags = self.ldflags_shared

            export_opts = []
            for sym in export_symbols or []:
                export_opts.append("/EXPORT:" + sym)

            ld_args = (
                ldflags + lib_opts + export_opts + objects + ['/OUT:' + output_filename]
            )

            # The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            build_temp = os.path.dirname(objects[0])
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename)
                )
                implib_file = os.path.join(build_temp, self.library_filename(dll_name))
                ld_args.append('/IMPLIB:' + implib_file)

            self.manifest_setup_ldargs(output_filename, build_temp, ld_args)

            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            self.mkpath(os.path.dirname(output_filename))
            try:
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)

            # embed the manifest
            # XXX - this is somewhat fragile - if mt.exe fails, distutils
            # will still consider the DLL up-to-date, but it will not have a
            # manifest.  Maybe we should link to a temp file?  OTOH, that
            # implies a build environment error that shouldn't go undetected.
            mfinfo = self.manifest_get_embed_info(target_desc, ld_args)
            if mfinfo is not None:
                mffilename, mfid = mfinfo
                out_arg = '-outputresource:{};{}'.format(output_filename, mfid)
                try:
                    self.spawn(['mt.exe', '-nologo', '-manifest', mffilename, out_arg])
                except DistutilsExecError as msg:
                    raise LinkError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def manifest_setup_ldargs(self, output_filename, build_temp, ld_args):
        # If we need a manifest at all, an embedded manifest is recommended.
        # See MSDN article titled
        # "How to: Embed a Manifest Inside a C/C++ Application"
        # (currently at http://msdn2.microsoft.com/en-us/library/ms235591(VS.80).aspx)
        # Ask the linker to generate the manifest in the temp dir, so
        # we can check it, and possibly embed it, later.
        temp_manifest = os.path.join(
            build_temp, os.path.basename(output_filename) + ".manifest"
        )
        ld_args.append('/MANIFESTFILE:' + temp_manifest)

    def manifest_get_embed_info(self, target_desc, ld_args):
        # If a manifest should be embedded, return a tuple of
        # (manifest_filename, resource_id).  Returns None if no manifest
        # should be embedded.  See http://bugs.python.org/issue7833 for why
        # we want to avoid any manifest for extension modules if we can)
        for arg in ld_args:
            if arg.startswith("/MANIFESTFILE:"):
                temp_manifest = arg.split(":", 1)[1]
                break
        else:
            # no /MANIFESTFILE so nothing to do.
            return None
        if target_desc == CCompiler.EXECUTABLE:
            # by default, executables always get the manifest with the
            # CRT referenced.
            mfid = 1
        else:
            # Extension modules try and avoid any manifest if possible.
            mfid = 2
            temp_manifest = self._remove_visual_c_ref(temp_manifest)
        if temp_manifest is None:
            return None
        return temp_manifest, mfid

    def _remove_visual_c_ref(self, manifest_file):
        try:
            # Remove references to the Visual C runtime, so they will
            # fall through to the Visual C dependency of Python.exe.
            # This way, when installed for a restricted user (e.g.
            # runtimes are not in WinSxS folder, but in Python's own
            # folder), the runtimes do not need to be in every folder
            # with .pyd's.
            # Returns either the filename of the modified manifest or
            # None if no manifest should be embedded.
            manifest_f = open(manifest_file)
            try:
                manifest_buf = manifest_f.read()
            finally:
                manifest_f.close()
            pattern = re.compile(
                r"""|)""",
                re.DOTALL,
            )
            manifest_buf = re.sub(pattern, "", manifest_buf)
            pattern = r"\s*"
            manifest_buf = re.sub(pattern, "", manifest_buf)
            # Now see if any other assemblies are referenced - if not, we
            # don't want a manifest embedded.
            pattern = re.compile(
                r"""|)""",
                re.DOTALL,
            )
            if re.search(pattern, manifest_buf) is None:
                return None

            manifest_f = open(manifest_file, 'w')
            try:
                manifest_f.write(manifest_buf)
                return manifest_file
            finally:
                manifest_f.close()
        except OSError:
            pass

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "/LIBPATH:" + dir

    def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(
            "don't know how to set runtime library search path for MSVC++"
        )

    def library_option(self, lib):
        return self.library_filename(lib)

    def find_library_file(self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename(name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

    # Helper methods for using the MSVC registry settings

    def find_exe(self, exe):
        """Return path to an MSVC executable program.

        Tries to find the program in several places: first, one of the
        MSVC program search paths from the registry; next, the directories
        in the PATH environment variable.  If any of those work, return an
        absolute path that is known to exist.  If none of them work, just
        return the original program name, 'exe'.
        """
        for p in self.__paths:
            fn = os.path.join(os.path.abspath(p), exe)
            if os.path.isfile(fn):
                return fn

        # didn't find it; try existing path
        for p in os.environ['Path'].split(';'):
            fn = os.path.join(os.path.abspath(p), exe)
            if os.path.isfile(fn):
                return fn

        return exe
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/msvccompiler.py0000644000175100001730000005603114467657412023140 0ustar00runnerdocker"""distutils.msvccompiler

Contains MSVCCompiler, an implementation of the abstract CCompiler class
for the Microsoft Visual Studio.
"""

# Written by Perry Stoll
# hacked by Robin Becker and Thomas Heller to do a better job of
#   finding DevStudio (through the registry)

import sys
import os
import warnings
from .errors import (
    DistutilsExecError,
    DistutilsPlatformError,
    CompileError,
    LibError,
    LinkError,
)
from .ccompiler import CCompiler, gen_lib_options
from ._log import log

_can_read_reg = False
try:
    import winreg

    _can_read_reg = True
    hkey_mod = winreg

    RegOpenKeyEx = winreg.OpenKeyEx
    RegEnumKey = winreg.EnumKey
    RegEnumValue = winreg.EnumValue
    RegError = winreg.error

except ImportError:
    try:
        import win32api
        import win32con

        _can_read_reg = True
        hkey_mod = win32con

        RegOpenKeyEx = win32api.RegOpenKeyEx
        RegEnumKey = win32api.RegEnumKey
        RegEnumValue = win32api.RegEnumValue
        RegError = win32api.error
    except ImportError:
        log.info(
            "Warning: Can't read registry to find the "
            "necessary compiler setting\n"
            "Make sure that Python modules winreg, "
            "win32api or win32con are installed."
        )
        pass

if _can_read_reg:
    HKEYS = (
        hkey_mod.HKEY_USERS,
        hkey_mod.HKEY_CURRENT_USER,
        hkey_mod.HKEY_LOCAL_MACHINE,
        hkey_mod.HKEY_CLASSES_ROOT,
    )


warnings.warn(
    "msvccompiler is deprecated and slated to be removed "
    "in the future. Please discontinue use or file an issue "
    "with pypa/distutils describing your use case.",
    DeprecationWarning,
)


def read_keys(base, key):
    """Return list of registry keys."""
    try:
        handle = RegOpenKeyEx(base, key)
    except RegError:
        return None
    L = []
    i = 0
    while True:
        try:
            k = RegEnumKey(handle, i)
        except RegError:
            break
        L.append(k)
        i += 1
    return L


def read_values(base, key):
    """Return dict of registry keys and values.

    All names are converted to lowercase.
    """
    try:
        handle = RegOpenKeyEx(base, key)
    except RegError:
        return None
    d = {}
    i = 0
    while True:
        try:
            name, value, type = RegEnumValue(handle, i)
        except RegError:
            break
        name = name.lower()
        d[convert_mbcs(name)] = convert_mbcs(value)
        i += 1
    return d


def convert_mbcs(s):
    dec = getattr(s, "decode", None)
    if dec is not None:
        try:
            s = dec("mbcs")
        except UnicodeError:
            pass
    return s


class MacroExpander:
    def __init__(self, version):
        self.macros = {}
        self.load_macros(version)

    def set_macro(self, macro, path, key):
        for base in HKEYS:
            d = read_values(base, path)
            if d:
                self.macros["$(%s)" % macro] = d[key]
                break

    def load_macros(self, version):
        vsbase = r"Software\Microsoft\VisualStudio\%0.1f" % version
        self.set_macro("VCInstallDir", vsbase + r"\Setup\VC", "productdir")
        self.set_macro("VSInstallDir", vsbase + r"\Setup\VS", "productdir")
        net = r"Software\Microsoft\.NETFramework"
        self.set_macro("FrameworkDir", net, "installroot")
        try:
            if version > 7.0:
                self.set_macro("FrameworkSDKDir", net, "sdkinstallrootv1.1")
            else:
                self.set_macro("FrameworkSDKDir", net, "sdkinstallroot")
        except KeyError:
            raise DistutilsPlatformError(
                """Python was built with Visual Studio 2003;
extensions must be built with a compiler than can generate compatible binaries.
Visual Studio 2003 was not found on this system. If you have Cygwin installed,
you can try compiling with MingW32, by passing "-c mingw32" to setup.py."""
            )

        p = r"Software\Microsoft\NET Framework Setup\Product"
        for base in HKEYS:
            try:
                h = RegOpenKeyEx(base, p)
            except RegError:
                continue
            key = RegEnumKey(h, 0)
            d = read_values(base, r"{}\{}".format(p, key))
            self.macros["$(FrameworkVersion)"] = d["version"]

    def sub(self, s):
        for k, v in self.macros.items():
            s = s.replace(k, v)
        return s


def get_build_version():
    """Return the version of MSVC that was used to build Python.

    For Python 2.3 and up, the version number is included in
    sys.version.  For earlier versions, assume the compiler is MSVC 6.
    """
    prefix = "MSC v."
    i = sys.version.find(prefix)
    if i == -1:
        return 6
    i = i + len(prefix)
    s, rest = sys.version[i:].split(" ", 1)
    majorVersion = int(s[:-2]) - 6
    if majorVersion >= 13:
        # v13 was skipped and should be v14
        majorVersion += 1
    minorVersion = int(s[2:3]) / 10.0
    # I don't think paths are affected by minor version in version 6
    if majorVersion == 6:
        minorVersion = 0
    if majorVersion >= 6:
        return majorVersion + minorVersion
    # else we don't know what version of the compiler this is
    return None


def get_build_architecture():
    """Return the processor architecture.

    Possible results are "Intel" or "AMD64".
    """

    prefix = " bit ("
    i = sys.version.find(prefix)
    if i == -1:
        return "Intel"
    j = sys.version.find(")", i)
    return sys.version[i + len(prefix) : j]


def normalize_and_reduce_paths(paths):
    """Return a list of normalized paths with duplicates removed.

    The current order of paths is maintained.
    """
    # Paths are normalized so things like:  /a and /a/ aren't both preserved.
    reduced_paths = []
    for p in paths:
        np = os.path.normpath(p)
        # XXX(nnorwitz): O(n**2), if reduced_paths gets long perhaps use a set.
        if np not in reduced_paths:
            reduced_paths.append(np)
    return reduced_paths


class MSVCCompiler(CCompiler):
    """Concrete class that implements an interface to Microsoft Visual C++,
    as defined by the CCompiler abstract class."""

    compiler_type = 'msvc'

    # Just set this so CCompiler's constructor doesn't barf.  We currently
    # don't use the 'set_executables()' bureaucracy provided by CCompiler,
    # as it really isn't necessary for this sort of single-compiler class.
    # Would be nice to have a consistent interface with UnixCCompiler,
    # though, so it's worth thinking about.
    executables = {}

    # Private class data (need to distinguish C from C++ source for compiler)
    _c_extensions = ['.c']
    _cpp_extensions = ['.cc', '.cpp', '.cxx']
    _rc_extensions = ['.rc']
    _mc_extensions = ['.mc']

    # Needed for the filename generation methods provided by the
    # base class, CCompiler.
    src_extensions = _c_extensions + _cpp_extensions + _rc_extensions + _mc_extensions
    res_extension = '.res'
    obj_extension = '.obj'
    static_lib_extension = '.lib'
    shared_lib_extension = '.dll'
    static_lib_format = shared_lib_format = '%s%s'
    exe_extension = '.exe'

    def __init__(self, verbose=0, dry_run=0, force=0):
        super().__init__(verbose, dry_run, force)
        self.__version = get_build_version()
        self.__arch = get_build_architecture()
        if self.__arch == "Intel":
            # x86
            if self.__version >= 7:
                self.__root = r"Software\Microsoft\VisualStudio"
                self.__macros = MacroExpander(self.__version)
            else:
                self.__root = r"Software\Microsoft\Devstudio"
            self.__product = "Visual Studio version %s" % self.__version
        else:
            # Win64. Assume this was built with the platform SDK
            self.__product = "Microsoft SDK compiler %s" % (self.__version + 6)

        self.initialized = False

    def initialize(self):
        self.__paths = []
        if (
            "DISTUTILS_USE_SDK" in os.environ
            and "MSSdk" in os.environ
            and self.find_exe("cl.exe")
        ):
            # Assume that the SDK set up everything alright; don't try to be
            # smarter
            self.cc = "cl.exe"
            self.linker = "link.exe"
            self.lib = "lib.exe"
            self.rc = "rc.exe"
            self.mc = "mc.exe"
        else:
            self.__paths = self.get_msvc_paths("path")

            if len(self.__paths) == 0:
                raise DistutilsPlatformError(
                    "Python was built with %s, "
                    "and extensions need to be built with the same "
                    "version of the compiler, but it isn't installed." % self.__product
                )

            self.cc = self.find_exe("cl.exe")
            self.linker = self.find_exe("link.exe")
            self.lib = self.find_exe("lib.exe")
            self.rc = self.find_exe("rc.exe")  # resource compiler
            self.mc = self.find_exe("mc.exe")  # message compiler
            self.set_path_env_var('lib')
            self.set_path_env_var('include')

        # extend the MSVC path with the current path
        try:
            for p in os.environ['path'].split(';'):
                self.__paths.append(p)
        except KeyError:
            pass
        self.__paths = normalize_and_reduce_paths(self.__paths)
        os.environ['path'] = ";".join(self.__paths)

        self.preprocess_options = None
        if self.__arch == "Intel":
            self.compile_options = ['/nologo', '/O2', '/MD', '/W3', '/GX', '/DNDEBUG']
            self.compile_options_debug = [
                '/nologo',
                '/Od',
                '/MDd',
                '/W3',
                '/GX',
                '/Z7',
                '/D_DEBUG',
            ]
        else:
            # Win64
            self.compile_options = ['/nologo', '/O2', '/MD', '/W3', '/GS-', '/DNDEBUG']
            self.compile_options_debug = [
                '/nologo',
                '/Od',
                '/MDd',
                '/W3',
                '/GS-',
                '/Z7',
                '/D_DEBUG',
            ]

        self.ldflags_shared = ['/DLL', '/nologo', '/INCREMENTAL:NO']
        if self.__version >= 7:
            self.ldflags_shared_debug = ['/DLL', '/nologo', '/INCREMENTAL:no', '/DEBUG']
        else:
            self.ldflags_shared_debug = [
                '/DLL',
                '/nologo',
                '/INCREMENTAL:no',
                '/pdb:None',
                '/DEBUG',
            ]
        self.ldflags_static = ['/nologo']

        self.initialized = True

    # -- Worker methods ------------------------------------------------

    def object_filenames(self, source_filenames, strip_dir=0, output_dir=''):
        # Copied from ccompiler.py, extended to return .res as 'object'-file
        # for .rc input file
        if output_dir is None:
            output_dir = ''
        obj_names = []
        for src_name in source_filenames:
            (base, ext) = os.path.splitext(src_name)
            base = os.path.splitdrive(base)[1]  # Chop off the drive
            base = base[os.path.isabs(base) :]  # If abs, chop off leading /
            if ext not in self.src_extensions:
                # Better to raise an exception instead of silently continuing
                # and later complain about sources and targets having
                # different lengths
                raise CompileError("Don't know how to compile %s" % src_name)
            if strip_dir:
                base = os.path.basename(base)
            if ext in self._rc_extensions:
                obj_names.append(os.path.join(output_dir, base + self.res_extension))
            elif ext in self._mc_extensions:
                obj_names.append(os.path.join(output_dir, base + self.res_extension))
            else:
                obj_names.append(os.path.join(output_dir, base + self.obj_extension))
        return obj_names

    def compile(  # noqa: C901
        self,
        sources,
        output_dir=None,
        macros=None,
        include_dirs=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        depends=None,
    ):
        if not self.initialized:
            self.initialize()
        compile_info = self._setup_compile(
            output_dir, macros, include_dirs, sources, depends, extra_postargs
        )
        macros, objects, extra_postargs, pp_opts, build = compile_info

        compile_opts = extra_preargs or []
        compile_opts.append('/c')
        if debug:
            compile_opts.extend(self.compile_options_debug)
        else:
            compile_opts.extend(self.compile_options)

        for obj in objects:
            try:
                src, ext = build[obj]
            except KeyError:
                continue
            if debug:
                # pass the full pathname to MSVC in debug mode,
                # this allows the debugger to find the source file
                # without asking the user to browse for it
                src = os.path.abspath(src)

            if ext in self._c_extensions:
                input_opt = "/Tc" + src
            elif ext in self._cpp_extensions:
                input_opt = "/Tp" + src
            elif ext in self._rc_extensions:
                # compile .RC to .RES file
                input_opt = src
                output_opt = "/fo" + obj
                try:
                    self.spawn([self.rc] + pp_opts + [output_opt] + [input_opt])
                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            elif ext in self._mc_extensions:
                # Compile .MC to .RC file to .RES file.
                #   * '-h dir' specifies the directory for the
                #     generated include file
                #   * '-r dir' specifies the target directory of the
                #     generated RC file and the binary message resource
                #     it includes
                #
                # For now (since there are no options to change this),
                # we use the source-directory for the include file and
                # the build directory for the RC file and message
                # resources. This works at least for win32all.
                h_dir = os.path.dirname(src)
                rc_dir = os.path.dirname(obj)
                try:
                    # first compile .MC to .RC and .H file
                    self.spawn([self.mc] + ['-h', h_dir, '-r', rc_dir] + [src])
                    base, _ = os.path.splitext(os.path.basename(src))
                    rc_file = os.path.join(rc_dir, base + '.rc')
                    # then compile .RC to .RES file
                    self.spawn([self.rc] + ["/fo" + obj] + [rc_file])

                except DistutilsExecError as msg:
                    raise CompileError(msg)
                continue
            else:
                # how to handle this file?
                raise CompileError(
                    "Don't know how to compile {} to {}".format(src, obj)
                )

            output_opt = "/Fo" + obj
            try:
                self.spawn(
                    [self.cc]
                    + compile_opts
                    + pp_opts
                    + [input_opt, output_opt]
                    + extra_postargs
                )
            except DistutilsExecError as msg:
                raise CompileError(msg)

        return objects

    def create_static_lib(
        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
    ):
        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        output_filename = self.library_filename(output_libname, output_dir=output_dir)

        if self._need_link(objects, output_filename):
            lib_args = objects + ['/OUT:' + output_filename]
            if debug:
                pass  # XXX what goes here?
            try:
                self.spawn([self.lib] + lib_args)
            except DistutilsExecError as msg:
                raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def link(  # noqa: C901
        self,
        target_desc,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        if not self.initialized:
            self.initialize()
        (objects, output_dir) = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
        (libraries, library_dirs, runtime_library_dirs) = fixed_args

        if runtime_library_dirs:
            self.warn(
                "I don't know what to do with 'runtime_library_dirs': "
                + str(runtime_library_dirs)
            )

        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            if target_desc == CCompiler.EXECUTABLE:
                if debug:
                    ldflags = self.ldflags_shared_debug[1:]
                else:
                    ldflags = self.ldflags_shared[1:]
            else:
                if debug:
                    ldflags = self.ldflags_shared_debug
                else:
                    ldflags = self.ldflags_shared

            export_opts = []
            for sym in export_symbols or []:
                export_opts.append("/EXPORT:" + sym)

            ld_args = (
                ldflags + lib_opts + export_opts + objects + ['/OUT:' + output_filename]
            )

            # The MSVC linker generates .lib and .exp files, which cannot be
            # suppressed by any linker switches. The .lib files may even be
            # needed! Make sure they are generated in the temporary build
            # directory. Since they have different names for debug and release
            # builds, they can go into the same directory.
            if export_symbols is not None:
                (dll_name, dll_ext) = os.path.splitext(
                    os.path.basename(output_filename)
                )
                implib_file = os.path.join(
                    os.path.dirname(objects[0]), self.library_filename(dll_name)
                )
                ld_args.append('/IMPLIB:' + implib_file)

            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)

            self.mkpath(os.path.dirname(output_filename))
            try:
                self.spawn([self.linker] + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)

        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "/LIBPATH:" + dir

    def runtime_library_dir_option(self, dir):
        raise DistutilsPlatformError(
            "don't know how to set runtime library search path for MSVC++"
        )

    def library_option(self, lib):
        return self.library_filename(lib)

    def find_library_file(self, dirs, lib, debug=0):
        # Prefer a debugging library if found (and requested), but deal
        # with it if we don't have one.
        if debug:
            try_names = [lib + "_d", lib]
        else:
            try_names = [lib]
        for dir in dirs:
            for name in try_names:
                libfile = os.path.join(dir, self.library_filename(name))
                if os.path.exists(libfile):
                    return libfile
        else:
            # Oops, didn't find it in *any* of 'dirs'
            return None

    # Helper methods for using the MSVC registry settings

    def find_exe(self, exe):
        """Return path to an MSVC executable program.

        Tries to find the program in several places: first, one of the
        MSVC program search paths from the registry; next, the directories
        in the PATH environment variable.  If any of those work, return an
        absolute path that is known to exist.  If none of them work, just
        return the original program name, 'exe'.
        """
        for p in self.__paths:
            fn = os.path.join(os.path.abspath(p), exe)
            if os.path.isfile(fn):
                return fn

        # didn't find it; try existing path
        for p in os.environ['Path'].split(';'):
            fn = os.path.join(os.path.abspath(p), exe)
            if os.path.isfile(fn):
                return fn

        return exe

    def get_msvc_paths(self, path, platform='x86'):
        """Get a list of devstudio directories (include, lib or path).

        Return a list of strings.  The list will be empty if unable to
        access the registry or appropriate registry keys not found.
        """
        if not _can_read_reg:
            return []

        path = path + " dirs"
        if self.__version >= 7:
            key = r"{}\{:0.1f}\VC\VC_OBJECTS_PLATFORM_INFO\Win32\Directories".format(
                self.__root,
                self.__version,
            )
        else:
            key = (
                r"%s\6.0\Build System\Components\Platforms"
                r"\Win32 (%s)\Directories" % (self.__root, platform)
            )

        for base in HKEYS:
            d = read_values(base, key)
            if d:
                if self.__version >= 7:
                    return self.__macros.sub(d[path]).split(";")
                else:
                    return d[path].split(";")
        # MSVC 6 seems to create the registry entries we need only when
        # the GUI is run.
        if self.__version == 6:
            for base in HKEYS:
                if read_values(base, r"%s\6.0" % self.__root) is not None:
                    self.warn(
                        "It seems you have Visual Studio 6 installed, "
                        "but the expected registry settings are not present.\n"
                        "You must at least run the Visual Studio GUI once "
                        "so that these entries are created."
                    )
                    break
        return []

    def set_path_env_var(self, name):
        """Set environment variable 'name' to an MSVC path type value.

        This is equivalent to a SET command prior to execution of spawned
        commands.
        """

        if name == "lib":
            p = self.get_msvc_paths("library")
        else:
            p = self.get_msvc_paths(name)
        if p:
            os.environ[name] = ';'.join(p)


if get_build_version() >= 8.0:
    log.debug("Importing new compiler from distutils.msvc9compiler")
    OldMSVCCompiler = MSVCCompiler
    from distutils.msvc9compiler import MSVCCompiler

    # get_build_architecture not really relevant now we support cross-compile
    from distutils.msvc9compiler import MacroExpander  # noqa: F811
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/py38compat.py0000644000175100001730000000033114467657412022434 0ustar00runnerdockerdef aix_platform(osname, version, release):
    try:
        import _aix_support

        return _aix_support.aix_platform()
    except ImportError:
        pass
    return "{}-{}.{}".format(osname, version, release)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/py39compat.py0000644000175100001730000000117714467657412022446 0ustar00runnerdockerimport sys
import platform


def add_ext_suffix_39(vars):
    """
    Ensure vars contains 'EXT_SUFFIX'. pypa/distutils#130
    """
    import _imp

    ext_suffix = _imp.extension_suffixes()[0]
    vars.update(
        EXT_SUFFIX=ext_suffix,
        # sysconfig sets SO to match EXT_SUFFIX, so maintain
        # that expectation.
        # https://github.com/python/cpython/blob/785cc6770588de087d09e89a69110af2542be208/Lib/sysconfig.py#L671-L673
        SO=ext_suffix,
    )


needs_ext_suffix = sys.version_info < (3, 10) and platform.system() == 'Windows'
add_ext_suffix = add_ext_suffix_39 if needs_ext_suffix else lambda vars: None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/spawn.py0000644000175100001730000000664714467657412021575 0ustar00runnerdocker"""distutils.spawn

Provides the 'spawn()' function, a front-end to various platform-
specific functions for launching another program in a sub-process.
Also provides the 'find_executable()' to search the path for a given
executable name.
"""

import sys
import os
import subprocess

from .errors import DistutilsExecError
from .debug import DEBUG
from ._log import log


def spawn(cmd, search_path=1, verbose=0, dry_run=0, env=None):  # noqa: C901
    """Run another program, specified as a command list 'cmd', in a new process.

    'cmd' is just the argument list for the new process, ie.
    cmd[0] is the program to run and cmd[1:] are the rest of its arguments.
    There is no way to run a program with a name different from that of its
    executable.

    If 'search_path' is true (the default), the system's executable
    search path will be used to find the program; otherwise, cmd[0]
    must be the exact path to the executable.  If 'dry_run' is true,
    the command will not actually be run.

    Raise DistutilsExecError if running the program fails in any way; just
    return on success.
    """
    # cmd is documented as a list, but just in case some code passes a tuple
    # in, protect our %-formatting code against horrible death
    cmd = list(cmd)

    log.info(subprocess.list2cmdline(cmd))
    if dry_run:
        return

    if search_path:
        executable = find_executable(cmd[0])
        if executable is not None:
            cmd[0] = executable

    env = env if env is not None else dict(os.environ)

    if sys.platform == 'darwin':
        from distutils.util import MACOSX_VERSION_VAR, get_macosx_target_ver

        macosx_target_ver = get_macosx_target_ver()
        if macosx_target_ver:
            env[MACOSX_VERSION_VAR] = macosx_target_ver

    try:
        proc = subprocess.Popen(cmd, env=env)
        proc.wait()
        exitcode = proc.returncode
    except OSError as exc:
        if not DEBUG:
            cmd = cmd[0]
        raise DistutilsExecError(
            "command {!r} failed: {}".format(cmd, exc.args[-1])
        ) from exc

    if exitcode:
        if not DEBUG:
            cmd = cmd[0]
        raise DistutilsExecError(
            "command {!r} failed with exit code {}".format(cmd, exitcode)
        )


def find_executable(executable, path=None):
    """Tries to find 'executable' in the directories listed in 'path'.

    A string listing directories separated by 'os.pathsep'; defaults to
    os.environ['PATH'].  Returns the complete filename or None if not found.
    """
    _, ext = os.path.splitext(executable)
    if (sys.platform == 'win32') and (ext != '.exe'):
        executable = executable + '.exe'

    if os.path.isfile(executable):
        return executable

    if path is None:
        path = os.environ.get('PATH', None)
        if path is None:
            try:
                path = os.confstr("CS_PATH")
            except (AttributeError, ValueError):
                # os.confstr() or CS_PATH is not available
                path = os.defpath
        # bpo-35755: Don't use os.defpath if the PATH environment variable is
        # set to an empty string

    # PATH='' doesn't match, whereas PATH=':' looks in the current directory
    if not path:
        return None

    paths = path.split(os.pathsep)
    for p in paths:
        f = os.path.join(p, executable)
        if os.path.isfile(f):
            # the file exists, we have a shot at spawn working
            return f
    return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/sysconfig.py0000644000175100001730000004476014467657412022447 0ustar00runnerdocker"""Provide access to Python's configuration information.  The specific
configuration variables available depend heavily on the platform and
configuration.  The values may be retrieved using
get_config_var(name), and the list of variables is available via
get_config_vars().keys().  Additional convenience functions are also
available.

Written by:   Fred L. Drake, Jr.
Email:        
"""

import os
import re
import sys
import sysconfig
import pathlib

from .errors import DistutilsPlatformError
from . import py39compat
from ._functools import pass_none

IS_PYPY = '__pypy__' in sys.builtin_module_names

# These are needed in a couple of spots, so just compute them once.
PREFIX = os.path.normpath(sys.prefix)
EXEC_PREFIX = os.path.normpath(sys.exec_prefix)
BASE_PREFIX = os.path.normpath(sys.base_prefix)
BASE_EXEC_PREFIX = os.path.normpath(sys.base_exec_prefix)

# Path to the base directory of the project. On Windows the binary may
# live in project/PCbuild/win32 or project/PCbuild/amd64.
# set for cross builds
if "_PYTHON_PROJECT_BASE" in os.environ:
    project_base = os.path.abspath(os.environ["_PYTHON_PROJECT_BASE"])
else:
    if sys.executable:
        project_base = os.path.dirname(os.path.abspath(sys.executable))
    else:
        # sys.executable can be empty if argv[0] has been changed and Python is
        # unable to retrieve the real program name
        project_base = os.getcwd()


def _is_python_source_dir(d):
    """
    Return True if the target directory appears to point to an
    un-installed Python.
    """
    modules = pathlib.Path(d).joinpath('Modules')
    return any(modules.joinpath(fn).is_file() for fn in ('Setup', 'Setup.local'))


_sys_home = getattr(sys, '_home', None)


def _is_parent(dir_a, dir_b):
    """
    Return True if a is a parent of b.
    """
    return os.path.normcase(dir_a).startswith(os.path.normcase(dir_b))


if os.name == 'nt':

    @pass_none
    def _fix_pcbuild(d):
        # In a venv, sys._home will be inside BASE_PREFIX rather than PREFIX.
        prefixes = PREFIX, BASE_PREFIX
        matched = (
            prefix
            for prefix in prefixes
            if _is_parent(d, os.path.join(prefix, "PCbuild"))
        )
        return next(matched, d)

    project_base = _fix_pcbuild(project_base)
    _sys_home = _fix_pcbuild(_sys_home)


def _python_build():
    if _sys_home:
        return _is_python_source_dir(_sys_home)
    return _is_python_source_dir(project_base)


python_build = _python_build()


# Calculate the build qualifier flags if they are defined.  Adding the flags
# to the include and lib directories only makes sense for an installation, not
# an in-source build.
build_flags = ''
try:
    if not python_build:
        build_flags = sys.abiflags
except AttributeError:
    # It's not a configure-based build, so the sys module doesn't have
    # this attribute, which is fine.
    pass


def get_python_version():
    """Return a string containing the major and minor Python version,
    leaving off the patchlevel.  Sample return values could be '1.5'
    or '2.2'.
    """
    return '%d.%d' % sys.version_info[:2]


def get_python_inc(plat_specific=0, prefix=None):
    """Return the directory containing installed Python header files.

    If 'plat_specific' is false (the default), this is the path to the
    non-platform-specific header files, i.e. Python.h and so on;
    otherwise, this is the path to platform-specific header files
    (namely pyconfig.h).

    If 'prefix' is supplied, use it instead of sys.base_prefix or
    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
    """
    default_prefix = BASE_EXEC_PREFIX if plat_specific else BASE_PREFIX
    resolved_prefix = prefix if prefix is not None else default_prefix
    try:
        getter = globals()[f'_get_python_inc_{os.name}']
    except KeyError:
        raise DistutilsPlatformError(
            "I don't know where Python installs its C header files "
            "on platform '%s'" % os.name
        )
    return getter(resolved_prefix, prefix, plat_specific)


@pass_none
def _extant(path):
    """
    Replace path with None if it doesn't exist.
    """
    return path if os.path.exists(path) else None


def _get_python_inc_posix(prefix, spec_prefix, plat_specific):
    if IS_PYPY and sys.version_info < (3, 8):
        return os.path.join(prefix, 'include')
    return (
        _get_python_inc_posix_python(plat_specific)
        or _extant(_get_python_inc_from_config(plat_specific, spec_prefix))
        or _get_python_inc_posix_prefix(prefix)
    )


def _get_python_inc_posix_python(plat_specific):
    """
    Assume the executable is in the build directory. The
    pyconfig.h file should be in the same directory. Since
    the build directory may not be the source directory,
    use "srcdir" from the makefile to find the "Include"
    directory.
    """
    if not python_build:
        return
    if plat_specific:
        return _sys_home or project_base
    incdir = os.path.join(get_config_var('srcdir'), 'Include')
    return os.path.normpath(incdir)


def _get_python_inc_from_config(plat_specific, spec_prefix):
    """
    If no prefix was explicitly specified, provide the include
    directory from the config vars. Useful when
    cross-compiling, since the config vars may come from
    the host
    platform Python installation, while the current Python
    executable is from the build platform installation.

    >>> monkeypatch = getfixture('monkeypatch')
    >>> gpifc = _get_python_inc_from_config
    >>> monkeypatch.setitem(gpifc.__globals__, 'get_config_var', str.lower)
    >>> gpifc(False, '/usr/bin/')
    >>> gpifc(False, '')
    >>> gpifc(False, None)
    'includepy'
    >>> gpifc(True, None)
    'confincludepy'
    """
    if spec_prefix is None:
        return get_config_var('CONF' * plat_specific + 'INCLUDEPY')


def _get_python_inc_posix_prefix(prefix):
    implementation = 'pypy' if IS_PYPY else 'python'
    python_dir = implementation + get_python_version() + build_flags
    return os.path.join(prefix, "include", python_dir)


def _get_python_inc_nt(prefix, spec_prefix, plat_specific):
    if python_build:
        # Include both the include and PC dir to ensure we can find
        # pyconfig.h
        return (
            os.path.join(prefix, "include")
            + os.path.pathsep
            + os.path.join(prefix, "PC")
        )
    return os.path.join(prefix, "include")


# allow this behavior to be monkey-patched. Ref pypa/distutils#2.
def _posix_lib(standard_lib, libpython, early_prefix, prefix):
    if standard_lib:
        return libpython
    else:
        return os.path.join(libpython, "site-packages")


def get_python_lib(plat_specific=0, standard_lib=0, prefix=None):
    """Return the directory containing the Python library (standard or
    site additions).

    If 'plat_specific' is true, return the directory containing
    platform-specific modules, i.e. any module from a non-pure-Python
    module distribution; otherwise, return the platform-shared library
    directory.  If 'standard_lib' is true, return the directory
    containing standard Python library modules; otherwise, return the
    directory for site-specific modules.

    If 'prefix' is supplied, use it instead of sys.base_prefix or
    sys.base_exec_prefix -- i.e., ignore 'plat_specific'.
    """

    if IS_PYPY and sys.version_info < (3, 8):
        # PyPy-specific schema
        if prefix is None:
            prefix = PREFIX
        if standard_lib:
            return os.path.join(prefix, "lib-python", sys.version[0])
        return os.path.join(prefix, 'site-packages')

    early_prefix = prefix

    if prefix is None:
        if standard_lib:
            prefix = plat_specific and BASE_EXEC_PREFIX or BASE_PREFIX
        else:
            prefix = plat_specific and EXEC_PREFIX or PREFIX

    if os.name == "posix":
        if plat_specific or standard_lib:
            # Platform-specific modules (any module from a non-pure-Python
            # module distribution) or standard Python library modules.
            libdir = getattr(sys, "platlibdir", "lib")
        else:
            # Pure Python
            libdir = "lib"
        implementation = 'pypy' if IS_PYPY else 'python'
        libpython = os.path.join(prefix, libdir, implementation + get_python_version())
        return _posix_lib(standard_lib, libpython, early_prefix, prefix)
    elif os.name == "nt":
        if standard_lib:
            return os.path.join(prefix, "Lib")
        else:
            return os.path.join(prefix, "Lib", "site-packages")
    else:
        raise DistutilsPlatformError(
            "I don't know where Python installs its library "
            "on platform '%s'" % os.name
        )


def customize_compiler(compiler):  # noqa: C901
    """Do any platform-specific customization of a CCompiler instance.

    Mainly needed on Unix, so we can plug in the information that
    varies across Unices and is stored in Python's Makefile.
    """
    if compiler.compiler_type == "unix":
        if sys.platform == "darwin":
            # Perform first-time customization of compiler-related
            # config vars on OS X now that we know we need a compiler.
            # This is primarily to support Pythons from binary
            # installers.  The kind and paths to build tools on
            # the user system may vary significantly from the system
            # that Python itself was built on.  Also the user OS
            # version and build tools may not support the same set
            # of CPU architectures for universal builds.
            global _config_vars
            # Use get_config_var() to ensure _config_vars is initialized.
            if not get_config_var('CUSTOMIZED_OSX_COMPILER'):
                import _osx_support

                _osx_support.customize_compiler(_config_vars)
                _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'

        (
            cc,
            cxx,
            cflags,
            ccshared,
            ldshared,
            shlib_suffix,
            ar,
            ar_flags,
        ) = get_config_vars(
            'CC',
            'CXX',
            'CFLAGS',
            'CCSHARED',
            'LDSHARED',
            'SHLIB_SUFFIX',
            'AR',
            'ARFLAGS',
        )

        if 'CC' in os.environ:
            newcc = os.environ['CC']
            if 'LDSHARED' not in os.environ and ldshared.startswith(cc):
                # If CC is overridden, use that as the default
                #       command for LDSHARED as well
                ldshared = newcc + ldshared[len(cc) :]
            cc = newcc
        if 'CXX' in os.environ:
            cxx = os.environ['CXX']
        if 'LDSHARED' in os.environ:
            ldshared = os.environ['LDSHARED']
        if 'CPP' in os.environ:
            cpp = os.environ['CPP']
        else:
            cpp = cc + " -E"  # not always
        if 'LDFLAGS' in os.environ:
            ldshared = ldshared + ' ' + os.environ['LDFLAGS']
        if 'CFLAGS' in os.environ:
            cflags = cflags + ' ' + os.environ['CFLAGS']
            ldshared = ldshared + ' ' + os.environ['CFLAGS']
        if 'CPPFLAGS' in os.environ:
            cpp = cpp + ' ' + os.environ['CPPFLAGS']
            cflags = cflags + ' ' + os.environ['CPPFLAGS']
            ldshared = ldshared + ' ' + os.environ['CPPFLAGS']
        if 'AR' in os.environ:
            ar = os.environ['AR']
        if 'ARFLAGS' in os.environ:
            archiver = ar + ' ' + os.environ['ARFLAGS']
        else:
            archiver = ar + ' ' + ar_flags

        cc_cmd = cc + ' ' + cflags
        compiler.set_executables(
            preprocessor=cpp,
            compiler=cc_cmd,
            compiler_so=cc_cmd + ' ' + ccshared,
            compiler_cxx=cxx,
            linker_so=ldshared,
            linker_exe=cc,
            archiver=archiver,
        )

        if 'RANLIB' in os.environ and compiler.executables.get('ranlib', None):
            compiler.set_executables(ranlib=os.environ['RANLIB'])

        compiler.shared_lib_extension = shlib_suffix


def get_config_h_filename():
    """Return full pathname of installed pyconfig.h file."""
    if python_build:
        if os.name == "nt":
            inc_dir = os.path.join(_sys_home or project_base, "PC")
        else:
            inc_dir = _sys_home or project_base
        return os.path.join(inc_dir, 'pyconfig.h')
    else:
        return sysconfig.get_config_h_filename()


def get_makefile_filename():
    """Return full pathname of installed Makefile from the Python build."""
    return sysconfig.get_makefile_filename()


def parse_config_h(fp, g=None):
    """Parse a config.h-style file.

    A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    return sysconfig.parse_config_h(fp, vars=g)


# Regexes needed for parsing Makefile (and similar syntaxes,
# like old-style Setup files).
_variable_rx = re.compile(r"([a-zA-Z][a-zA-Z0-9_]+)\s*=\s*(.*)")
_findvar1_rx = re.compile(r"\$\(([A-Za-z][A-Za-z0-9_]*)\)")
_findvar2_rx = re.compile(r"\${([A-Za-z][A-Za-z0-9_]*)}")


def parse_makefile(fn, g=None):  # noqa: C901
    """Parse a Makefile-style file.

    A dictionary containing name/value pairs is returned.  If an
    optional dictionary is passed in as the second argument, it is
    used instead of a new dictionary.
    """
    from distutils.text_file import TextFile

    fp = TextFile(
        fn, strip_comments=1, skip_blanks=1, join_lines=1, errors="surrogateescape"
    )

    if g is None:
        g = {}
    done = {}
    notdone = {}

    while True:
        line = fp.readline()
        if line is None:  # eof
            break
        m = _variable_rx.match(line)
        if m:
            n, v = m.group(1, 2)
            v = v.strip()
            # `$$' is a literal `$' in make
            tmpv = v.replace('$$', '')

            if "$" in tmpv:
                notdone[n] = v
            else:
                try:
                    v = int(v)
                except ValueError:
                    # insert literal `$'
                    done[n] = v.replace('$$', '$')
                else:
                    done[n] = v

    # Variables with a 'PY_' prefix in the makefile. These need to
    # be made available without that prefix through sysconfig.
    # Special care is needed to ensure that variable expansion works, even
    # if the expansion uses the name without a prefix.
    renamed_variables = ('CFLAGS', 'LDFLAGS', 'CPPFLAGS')

    # do variable interpolation here
    while notdone:
        for name in list(notdone):
            value = notdone[name]
            m = _findvar1_rx.search(value) or _findvar2_rx.search(value)
            if m:
                n = m.group(1)
                found = True
                if n in done:
                    item = str(done[n])
                elif n in notdone:
                    # get it on a subsequent round
                    found = False
                elif n in os.environ:
                    # do it like make: fall back to environment
                    item = os.environ[n]

                elif n in renamed_variables:
                    if name.startswith('PY_') and name[3:] in renamed_variables:
                        item = ""

                    elif 'PY_' + n in notdone:
                        found = False

                    else:
                        item = str(done['PY_' + n])
                else:
                    done[n] = item = ""
                if found:
                    after = value[m.end() :]
                    value = value[: m.start()] + item + after
                    if "$" in after:
                        notdone[name] = value
                    else:
                        try:
                            value = int(value)
                        except ValueError:
                            done[name] = value.strip()
                        else:
                            done[name] = value
                        del notdone[name]

                        if name.startswith('PY_') and name[3:] in renamed_variables:
                            name = name[3:]
                            if name not in done:
                                done[name] = value
            else:
                # bogus variable reference; just drop it since we can't deal
                del notdone[name]

    fp.close()

    # strip spurious spaces
    for k, v in done.items():
        if isinstance(v, str):
            done[k] = v.strip()

    # save the results in the global dictionary
    g.update(done)
    return g


def expand_makefile_vars(s, vars):
    """Expand Makefile-style variables -- "${foo}" or "$(foo)" -- in
    'string' according to 'vars' (a dictionary mapping variable names to
    values).  Variables not present in 'vars' are silently expanded to the
    empty string.  The variable values in 'vars' should not contain further
    variable expansions; if 'vars' is the output of 'parse_makefile()',
    you're fine.  Returns a variable-expanded version of 's'.
    """

    # This algorithm does multiple expansion, so if vars['foo'] contains
    # "${bar}", it will expand ${foo} to ${bar}, and then expand
    # ${bar}... and so forth.  This is fine as long as 'vars' comes from
    # 'parse_makefile()', which takes care of such expansions eagerly,
    # according to make's variable expansion semantics.

    while True:
        m = _findvar1_rx.search(s) or _findvar2_rx.search(s)
        if m:
            (beg, end) = m.span()
            s = s[0:beg] + vars.get(m.group(1)) + s[end:]
        else:
            break
    return s


_config_vars = None


def get_config_vars(*args):
    """With no arguments, return a dictionary of all configuration
    variables relevant for the current platform.  Generally this includes
    everything needed to build extensions and install both pure modules and
    extensions.  On Unix, this means every variable defined in Python's
    installed Makefile; on Windows it's a much smaller set.

    With arguments, return a list of values that result from looking up
    each argument in the configuration variable dictionary.
    """
    global _config_vars
    if _config_vars is None:
        _config_vars = sysconfig.get_config_vars().copy()
        py39compat.add_ext_suffix(_config_vars)

    return [_config_vars.get(name) for name in args] if args else _config_vars


def get_config_var(name):
    """Return the value of a single variable using the dictionary
    returned by 'get_config_vars()'.  Equivalent to
    get_config_vars().get(name)
    """
    if name == 'SO':
        import warnings

        warnings.warn('SO is deprecated, use EXT_SUFFIX', DeprecationWarning, 2)
    return get_config_vars().get(name)
././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1692360483.52755
setuptools-68.1.2/setuptools/_distutils/tests/0000755000175100001730000000000014467657444021225 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/__init__.py0000644000175100001730000000043714467657412023335 0ustar00runnerdocker"""
Test suite for distutils.

Tests for the command classes in the distutils.command package are
included in distutils.tests as well, instead of using a separate
distutils.command.tests package, since command identification is done
by import rather than matching pre-defined names.
"""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/py37compat.py0000644000175100001730000000051414467657412023600 0ustar00runnerdockerimport os
import sys
import platform


def subprocess_args_compat(*args):
    return list(map(os.fspath, args))


def subprocess_args_passthrough(*args):
    return list(args)


subprocess_args = (
    subprocess_args_compat
    if platform.system() == "Windows" and sys.version_info < (3, 8)
    else subprocess_args_passthrough
)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/py38compat.py0000644000175100001730000000176714467657412023614 0ustar00runnerdocker# flake8: noqa

import contextlib
import builtins
import sys

from test.support import requires_zlib
import test.support


ModuleNotFoundError = getattr(builtins, 'ModuleNotFoundError', ImportError)

try:
    from test.support.warnings_helper import check_warnings
except (ModuleNotFoundError, ImportError):
    from test.support import check_warnings


try:
    from test.support.os_helper import (
        rmtree,
        EnvironmentVarGuard,
        unlink,
        skip_unless_symlink,
        temp_dir,
    )
except (ModuleNotFoundError, ImportError):
    from test.support import (
        rmtree,
        EnvironmentVarGuard,
        unlink,
        skip_unless_symlink,
        temp_dir,
    )


try:
    from test.support.import_helper import (
        DirsOnSysPath,
        CleanImport,
    )
except (ModuleNotFoundError, ImportError):
    from test.support import (
        DirsOnSysPath,
        CleanImport,
    )


if sys.version_info < (3, 9):
    requires_zlib = lambda: test.support.requires_zlib
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/support.py0000644000175100001730000000776114467657412023321 0ustar00runnerdocker"""Support code for distutils test cases."""
import os
import sys
import shutil
import tempfile
import sysconfig
import itertools
import pathlib

import pytest
from more_itertools import always_iterable

from distutils.core import Distribution


@pytest.mark.usefixtures('distutils_managed_tempdir')
class TempdirManager:
    """
    Mix-in class that handles temporary directories for test cases.
    """

    def mkdtemp(self):
        """Create a temporary directory that will be cleaned up.

        Returns the path of the directory.
        """
        d = tempfile.mkdtemp()
        self.tempdirs.append(d)
        return d

    def write_file(self, path, content='xxx'):
        """Writes a file in the given path.

        path can be a string or a sequence.
        """
        pathlib.Path(*always_iterable(path)).write_text(content)

    def create_dist(self, pkg_name='foo', **kw):
        """Will generate a test environment.

        This function creates:
         - a Distribution instance using keywords
         - a temporary directory with a package structure

        It returns the package directory and the distribution
        instance.
        """
        tmp_dir = self.mkdtemp()
        pkg_dir = os.path.join(tmp_dir, pkg_name)
        os.mkdir(pkg_dir)
        dist = Distribution(attrs=kw)

        return pkg_dir, dist


class DummyCommand:
    """Class to store options for retrieval via set_undefined_options()."""

    def __init__(self, **kwargs):
        vars(self).update(kwargs)

    def ensure_finalized(self):
        pass


def copy_xxmodule_c(directory):
    """Helper for tests that need the xxmodule.c source file.

    Example use:

        def test_compile(self):
            copy_xxmodule_c(self.tmpdir)
            self.assertIn('xxmodule.c', os.listdir(self.tmpdir))

    If the source file can be found, it will be copied to *directory*.  If not,
    the test will be skipped.  Errors during copy are not caught.
    """
    shutil.copy(_get_xxmodule_path(), os.path.join(directory, 'xxmodule.c'))


def _get_xxmodule_path():
    source_name = 'xxmodule.c' if sys.version_info > (3, 9) else 'xxmodule-3.8.c'
    return os.path.join(os.path.dirname(__file__), source_name)


def fixup_build_ext(cmd):
    """Function needed to make build_ext tests pass.

    When Python was built with --enable-shared on Unix, -L. is not enough to
    find libpython.so, because regrtest runs in a tempdir, not in the
    source directory where the .so lives.

    When Python was built with in debug mode on Windows, build_ext commands
    need their debug attribute set, and it is not done automatically for
    some reason.

    This function handles both of these things.  Example use:

        cmd = build_ext(dist)
        support.fixup_build_ext(cmd)
        cmd.ensure_finalized()

    Unlike most other Unix platforms, Mac OS X embeds absolute paths
    to shared libraries into executables, so the fixup is not needed there.
    """
    if os.name == 'nt':
        cmd.debug = sys.executable.endswith('_d.exe')
    elif sysconfig.get_config_var('Py_ENABLE_SHARED'):
        # To further add to the shared builds fun on Unix, we can't just add
        # library_dirs to the Extension() instance because that doesn't get
        # plumbed through to the final compiler command.
        runshared = sysconfig.get_config_var('RUNSHARED')
        if runshared is None:
            cmd.library_dirs = ['.']
        else:
            if sys.platform == 'darwin':
                cmd.library_dirs = []
            else:
                name, equals, value = runshared.partition('=')
                cmd.library_dirs = [d for d in value.split(os.pathsep) if d]


def combine_markers(cls):
    """
    pytest will honor markers as found on the class, but when
    markers are on multiple subclasses, only one appears. Use
    this decorator to combine those markers.
    """
    cls.pytestmark = [
        mark
        for base in itertools.chain([cls], cls.__bases__)
        for mark in getattr(base, 'pytestmark', [])
    ]
    return cls
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_archive_util.py0000644000175100001730000003116714467657412025317 0ustar00runnerdocker"""Tests for distutils.archive_util."""
import os
import sys
import tarfile
from os.path import splitdrive
import warnings
import functools
import operator
import pathlib

import pytest
import path

from distutils import archive_util
from distutils.archive_util import (
    check_archive_formats,
    make_tarball,
    make_zipfile,
    make_archive,
    ARCHIVE_FORMATS,
)
from distutils.spawn import spawn
from distutils.tests import support
from test.support import patch
from .unix_compat import require_unix_id, require_uid_0, grp, pwd, UID_0_SUPPORT

from .py38compat import check_warnings


def can_fs_encode(filename):
    """
    Return True if the filename can be saved in the file system.
    """
    if os.path.supports_unicode_filenames:
        return True
    try:
        filename.encode(sys.getfilesystemencoding())
    except UnicodeEncodeError:
        return False
    return True


def all_equal(values):
    return functools.reduce(operator.eq, values)


def same_drive(*paths):
    return all_equal(pathlib.Path(path).drive for path in paths)


class ArchiveUtilTestCase(support.TempdirManager):
    @pytest.mark.usefixtures('needs_zlib')
    def test_make_tarball(self, name='archive'):
        # creating something to tar
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, name, '.tar.gz')
        # trying an uncompressed one
        self._make_tarball(tmpdir, name, '.tar', compress=None)

    @pytest.mark.usefixtures('needs_zlib')
    def test_make_tarball_gzip(self):
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, 'archive', '.tar.gz', compress='gzip')

    def test_make_tarball_bzip2(self):
        pytest.importorskip('bz2')
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, 'archive', '.tar.bz2', compress='bzip2')

    def test_make_tarball_xz(self):
        pytest.importorskip('lzma')
        tmpdir = self._create_files()
        self._make_tarball(tmpdir, 'archive', '.tar.xz', compress='xz')

    @pytest.mark.skipif("not can_fs_encode('årchiv')")
    def test_make_tarball_latin1(self):
        """
        Mirror test_make_tarball, except filename contains latin characters.
        """
        self.test_make_tarball('årchiv')  # note this isn't a real word

    @pytest.mark.skipif("not can_fs_encode('のアーカイブ')")
    def test_make_tarball_extended(self):
        """
        Mirror test_make_tarball, except filename contains extended
        characters outside the latin charset.
        """
        self.test_make_tarball('のアーカイブ')  # japanese for archive

    def _make_tarball(self, tmpdir, target_name, suffix, **kwargs):
        tmpdir2 = self.mkdtemp()
        if same_drive(tmpdir, tmpdir2):
            pytest.skip("source and target should be on same drive")

        base_name = os.path.join(tmpdir2, target_name)

        # working with relative paths to avoid tar warnings
        with path.Path(tmpdir):
            make_tarball(splitdrive(base_name)[1], 'dist', **kwargs)

        # check if the compressed tarball was created
        tarball = base_name + suffix
        assert os.path.exists(tarball)
        assert self._tarinfo(tarball) == self._created_files

    def _tarinfo(self, path):
        tar = tarfile.open(path)
        try:
            names = tar.getnames()
            names.sort()
            return names
        finally:
            tar.close()

    _zip_created_files = [
        'dist/',
        'dist/file1',
        'dist/file2',
        'dist/sub/',
        'dist/sub/file3',
        'dist/sub2/',
    ]
    _created_files = [p.rstrip('/') for p in _zip_created_files]

    def _create_files(self):
        # creating something to tar
        tmpdir = self.mkdtemp()
        dist = os.path.join(tmpdir, 'dist')
        os.mkdir(dist)
        self.write_file([dist, 'file1'], 'xxx')
        self.write_file([dist, 'file2'], 'xxx')
        os.mkdir(os.path.join(dist, 'sub'))
        self.write_file([dist, 'sub', 'file3'], 'xxx')
        os.mkdir(os.path.join(dist, 'sub2'))
        return tmpdir

    @pytest.mark.usefixtures('needs_zlib')
    @pytest.mark.skipif("not (find_executable('tar') and find_executable('gzip'))")
    def test_tarfile_vs_tar(self):
        tmpdir = self._create_files()
        tmpdir2 = self.mkdtemp()
        base_name = os.path.join(tmpdir2, 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(base_name, 'dist')
        finally:
            os.chdir(old_dir)

        # check if the compressed tarball was created
        tarball = base_name + '.tar.gz'
        assert os.path.exists(tarball)

        # now create another tarball using `tar`
        tarball2 = os.path.join(tmpdir, 'archive2.tar.gz')
        tar_cmd = ['tar', '-cf', 'archive2.tar', 'dist']
        gzip_cmd = ['gzip', '-f', '-9', 'archive2.tar']
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            spawn(tar_cmd)
            spawn(gzip_cmd)
        finally:
            os.chdir(old_dir)

        assert os.path.exists(tarball2)
        # let's compare both tarballs
        assert self._tarinfo(tarball) == self._created_files
        assert self._tarinfo(tarball2) == self._created_files

        # trying an uncompressed one
        base_name = os.path.join(tmpdir2, 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(base_name, 'dist', compress=None)
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar'
        assert os.path.exists(tarball)

        # now for a dry_run
        base_name = os.path.join(tmpdir2, 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            make_tarball(base_name, 'dist', compress=None, dry_run=True)
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar'
        assert os.path.exists(tarball)

    @pytest.mark.skipif("not find_executable('compress')")
    def test_compress_deprecated(self):
        tmpdir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')

        # using compress and testing the DeprecationWarning
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            with check_warnings() as w:
                warnings.simplefilter("always")
                make_tarball(base_name, 'dist', compress='compress')
        finally:
            os.chdir(old_dir)
        tarball = base_name + '.tar.Z'
        assert os.path.exists(tarball)
        assert len(w.warnings) == 1

        # same test with dry_run
        os.remove(tarball)
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        try:
            with check_warnings() as w:
                warnings.simplefilter("always")
                make_tarball(base_name, 'dist', compress='compress', dry_run=True)
        finally:
            os.chdir(old_dir)
        assert not os.path.exists(tarball)
        assert len(w.warnings) == 1

    @pytest.mark.usefixtures('needs_zlib')
    def test_make_zipfile(self):
        zipfile = pytest.importorskip('zipfile')
        # creating something to tar
        tmpdir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        with path.Path(tmpdir):
            make_zipfile(base_name, 'dist')

        # check if the compressed tarball was created
        tarball = base_name + '.zip'
        assert os.path.exists(tarball)
        with zipfile.ZipFile(tarball) as zf:
            assert sorted(zf.namelist()) == self._zip_created_files

    def test_make_zipfile_no_zlib(self):
        zipfile = pytest.importorskip('zipfile')
        patch(self, archive_util.zipfile, 'zlib', None)  # force zlib ImportError

        called = []
        zipfile_class = zipfile.ZipFile

        def fake_zipfile(*a, **kw):
            if kw.get('compression', None) == zipfile.ZIP_STORED:
                called.append((a, kw))
            return zipfile_class(*a, **kw)

        patch(self, archive_util.zipfile, 'ZipFile', fake_zipfile)

        # create something to tar and compress
        tmpdir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        with path.Path(tmpdir):
            make_zipfile(base_name, 'dist')

        tarball = base_name + '.zip'
        assert called == [((tarball, "w"), {'compression': zipfile.ZIP_STORED})]
        assert os.path.exists(tarball)
        with zipfile.ZipFile(tarball) as zf:
            assert sorted(zf.namelist()) == self._zip_created_files

    def test_check_archive_formats(self):
        assert check_archive_formats(['gztar', 'xxx', 'zip']) == 'xxx'
        assert (
            check_archive_formats(['gztar', 'bztar', 'xztar', 'ztar', 'tar', 'zip'])
            is None
        )

    def test_make_archive(self):
        tmpdir = self.mkdtemp()
        base_name = os.path.join(tmpdir, 'archive')
        with pytest.raises(ValueError):
            make_archive(base_name, 'xxx')

    def test_make_archive_cwd(self):
        current_dir = os.getcwd()

        def _breaks(*args, **kw):
            raise RuntimeError()

        ARCHIVE_FORMATS['xxx'] = (_breaks, [], 'xxx file')
        try:
            try:
                make_archive('xxx', 'xxx', root_dir=self.mkdtemp())
            except Exception:
                pass
            assert os.getcwd() == current_dir
        finally:
            ARCHIVE_FORMATS.pop('xxx')

    def test_make_archive_tar(self):
        base_dir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        res = make_archive(base_name, 'tar', base_dir, 'dist')
        assert os.path.exists(res)
        assert os.path.basename(res) == 'archive.tar'
        assert self._tarinfo(res) == self._created_files

    @pytest.mark.usefixtures('needs_zlib')
    def test_make_archive_gztar(self):
        base_dir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        res = make_archive(base_name, 'gztar', base_dir, 'dist')
        assert os.path.exists(res)
        assert os.path.basename(res) == 'archive.tar.gz'
        assert self._tarinfo(res) == self._created_files

    def test_make_archive_bztar(self):
        pytest.importorskip('bz2')
        base_dir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        res = make_archive(base_name, 'bztar', base_dir, 'dist')
        assert os.path.exists(res)
        assert os.path.basename(res) == 'archive.tar.bz2'
        assert self._tarinfo(res) == self._created_files

    def test_make_archive_xztar(self):
        pytest.importorskip('lzma')
        base_dir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        res = make_archive(base_name, 'xztar', base_dir, 'dist')
        assert os.path.exists(res)
        assert os.path.basename(res) == 'archive.tar.xz'
        assert self._tarinfo(res) == self._created_files

    def test_make_archive_owner_group(self):
        # testing make_archive with owner and group, with various combinations
        # this works even if there's not gid/uid support
        if UID_0_SUPPORT:
            group = grp.getgrgid(0)[0]
            owner = pwd.getpwuid(0)[0]
        else:
            group = owner = 'root'

        base_dir = self._create_files()
        root_dir = self.mkdtemp()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        res = make_archive(
            base_name, 'zip', root_dir, base_dir, owner=owner, group=group
        )
        assert os.path.exists(res)

        res = make_archive(base_name, 'zip', root_dir, base_dir)
        assert os.path.exists(res)

        res = make_archive(
            base_name, 'tar', root_dir, base_dir, owner=owner, group=group
        )
        assert os.path.exists(res)

        res = make_archive(
            base_name, 'tar', root_dir, base_dir, owner='kjhkjhkjg', group='oihohoh'
        )
        assert os.path.exists(res)

    @pytest.mark.usefixtures('needs_zlib')
    @require_unix_id
    @require_uid_0
    def test_tarfile_root_owner(self):
        tmpdir = self._create_files()
        base_name = os.path.join(self.mkdtemp(), 'archive')
        old_dir = os.getcwd()
        os.chdir(tmpdir)
        group = grp.getgrgid(0)[0]
        owner = pwd.getpwuid(0)[0]
        try:
            archive_name = make_tarball(
                base_name, 'dist', compress=None, owner=owner, group=group
            )
        finally:
            os.chdir(old_dir)

        # check if the compressed tarball was created
        assert os.path.exists(archive_name)

        # now checks the rights
        archive = tarfile.open(archive_name)
        try:
            for member in archive.getmembers():
                assert member.uid == 0
                assert member.gid == 0
        finally:
            archive.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_bdist.py0000644000175100001730000000256214467657412023743 0ustar00runnerdocker"""Tests for distutils.command.bdist."""
from distutils.command.bdist import bdist
from distutils.tests import support


class TestBuild(support.TempdirManager):
    def test_formats(self):
        # let's create a command and make sure
        # we can set the format
        dist = self.create_dist()[1]
        cmd = bdist(dist)
        cmd.formats = ['gztar']
        cmd.ensure_finalized()
        assert cmd.formats == ['gztar']

        # what formats does bdist offer?
        formats = [
            'bztar',
            'gztar',
            'rpm',
            'tar',
            'xztar',
            'zip',
            'ztar',
        ]
        found = sorted(cmd.format_commands)
        assert found == formats

    def test_skip_build(self):
        # bug #10946: bdist --skip-build should trickle down to subcommands
        dist = self.create_dist()[1]
        cmd = bdist(dist)
        cmd.skip_build = 1
        cmd.ensure_finalized()
        dist.command_obj['bdist'] = cmd

        names = [
            'bdist_dumb',
        ]  # bdist_rpm does not support --skip-build

        for name in names:
            subcmd = cmd.get_finalized_command(name)
            if getattr(subcmd, '_unsupported', False):
                # command is not supported on this build
                continue
            assert subcmd.skip_build, '%s should take --skip-build from bdist' % name
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_bdist_dumb.py0000644000175100001730000000437714467657412024760 0ustar00runnerdocker"""Tests for distutils.command.bdist_dumb."""

import os
import sys
import zipfile

import pytest

from distutils.core import Distribution
from distutils.command.bdist_dumb import bdist_dumb
from distutils.tests import support

SETUP_PY = """\
from distutils.core import setup
import foo

setup(name='foo', version='0.1', py_modules=['foo'],
      url='xxx', author='xxx', author_email='xxx')

"""


@support.combine_markers
@pytest.mark.usefixtures('save_env')
@pytest.mark.usefixtures('save_argv')
@pytest.mark.usefixtures('save_cwd')
class TestBuildDumb(
    support.TempdirManager,
):
    @pytest.mark.usefixtures('needs_zlib')
    def test_simple_built(self):
        # let's create a simple package
        tmp_dir = self.mkdtemp()
        pkg_dir = os.path.join(tmp_dir, 'foo')
        os.mkdir(pkg_dir)
        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
        self.write_file((pkg_dir, 'foo.py'), '#')
        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
        self.write_file((pkg_dir, 'README'), '')

        dist = Distribution(
            {
                'name': 'foo',
                'version': '0.1',
                'py_modules': ['foo'],
                'url': 'xxx',
                'author': 'xxx',
                'author_email': 'xxx',
            }
        )
        dist.script_name = 'setup.py'
        os.chdir(pkg_dir)

        sys.argv = ['setup.py']
        cmd = bdist_dumb(dist)

        # so the output is the same no matter
        # what is the platform
        cmd.format = 'zip'

        cmd.ensure_finalized()
        cmd.run()

        # see what we have
        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
        base = "{}.{}.zip".format(dist.get_fullname(), cmd.plat_name)

        assert dist_created == [base]

        # now let's check what we have in the zip file
        fp = zipfile.ZipFile(os.path.join('dist', base))
        try:
            contents = fp.namelist()
        finally:
            fp.close()

        contents = sorted(filter(None, map(os.path.basename, contents)))
        wanted = ['foo-0.1-py%s.%s.egg-info' % sys.version_info[:2], 'foo.py']
        if not sys.dont_write_bytecode:
            wanted.append('foo.%s.pyc' % sys.implementation.cache_tag)
        assert contents == sorted(wanted)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_bdist_rpm.py0000644000175100001730000000774514467657412024631 0ustar00runnerdocker"""Tests for distutils.command.bdist_rpm."""

import sys
import os

import pytest

from distutils.core import Distribution
from distutils.command.bdist_rpm import bdist_rpm
from distutils.tests import support
from distutils.spawn import find_executable  # noqa: F401

from .py38compat import requires_zlib


SETUP_PY = """\
from distutils.core import setup
import foo

setup(name='foo', version='0.1', py_modules=['foo'],
      url='xxx', author='xxx', author_email='xxx')

"""


@pytest.fixture(autouse=True)
def sys_executable_encodable():
    try:
        sys.executable.encode('UTF-8')
    except UnicodeEncodeError:
        pytest.skip("sys.executable is not encodable to UTF-8")


mac_woes = pytest.mark.skipif(
    "not sys.platform.startswith('linux')",
    reason='spurious sdtout/stderr output under macOS',
)


@pytest.mark.usefixtures('save_env')
@pytest.mark.usefixtures('save_argv')
@pytest.mark.usefixtures('save_cwd')
class TestBuildRpm(
    support.TempdirManager,
):
    @mac_woes
    @requires_zlib()
    @pytest.mark.skipif("not find_executable('rpm')")
    @pytest.mark.skipif("not find_executable('rpmbuild')")
    def test_quiet(self):
        # let's create a package
        tmp_dir = self.mkdtemp()
        os.environ['HOME'] = tmp_dir  # to confine dir '.rpmdb' creation
        pkg_dir = os.path.join(tmp_dir, 'foo')
        os.mkdir(pkg_dir)
        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
        self.write_file((pkg_dir, 'foo.py'), '#')
        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
        self.write_file((pkg_dir, 'README'), '')

        dist = Distribution(
            {
                'name': 'foo',
                'version': '0.1',
                'py_modules': ['foo'],
                'url': 'xxx',
                'author': 'xxx',
                'author_email': 'xxx',
            }
        )
        dist.script_name = 'setup.py'
        os.chdir(pkg_dir)

        sys.argv = ['setup.py']
        cmd = bdist_rpm(dist)
        cmd.fix_python = True

        # running in quiet mode
        cmd.quiet = 1
        cmd.ensure_finalized()
        cmd.run()

        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
        assert 'foo-0.1-1.noarch.rpm' in dist_created

        # bug #2945: upload ignores bdist_rpm files
        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files

    @mac_woes
    @requires_zlib()
    # http://bugs.python.org/issue1533164
    @pytest.mark.skipif("not find_executable('rpm')")
    @pytest.mark.skipif("not find_executable('rpmbuild')")
    def test_no_optimize_flag(self):
        # let's create a package that breaks bdist_rpm
        tmp_dir = self.mkdtemp()
        os.environ['HOME'] = tmp_dir  # to confine dir '.rpmdb' creation
        pkg_dir = os.path.join(tmp_dir, 'foo')
        os.mkdir(pkg_dir)
        self.write_file((pkg_dir, 'setup.py'), SETUP_PY)
        self.write_file((pkg_dir, 'foo.py'), '#')
        self.write_file((pkg_dir, 'MANIFEST.in'), 'include foo.py')
        self.write_file((pkg_dir, 'README'), '')

        dist = Distribution(
            {
                'name': 'foo',
                'version': '0.1',
                'py_modules': ['foo'],
                'url': 'xxx',
                'author': 'xxx',
                'author_email': 'xxx',
            }
        )
        dist.script_name = 'setup.py'
        os.chdir(pkg_dir)

        sys.argv = ['setup.py']
        cmd = bdist_rpm(dist)
        cmd.fix_python = True

        cmd.quiet = 1
        cmd.ensure_finalized()
        cmd.run()

        dist_created = os.listdir(os.path.join(pkg_dir, 'dist'))
        assert 'foo-0.1-1.noarch.rpm' in dist_created

        # bug #2945: upload ignores bdist_rpm files
        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.src.rpm') in dist.dist_files
        assert ('bdist_rpm', 'any', 'dist/foo-0.1-1.noarch.rpm') in dist.dist_files

        os.remove(os.path.join(pkg_dir, 'dist', 'foo-0.1-1.noarch.rpm'))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_build.py0000644000175100001730000000312114467657412023725 0ustar00runnerdocker"""Tests for distutils.command.build."""
import os
import sys

from distutils.command.build import build
from distutils.tests import support
from sysconfig import get_platform


class TestBuild(support.TempdirManager):
    def test_finalize_options(self):
        pkg_dir, dist = self.create_dist()
        cmd = build(dist)
        cmd.finalize_options()

        # if not specified, plat_name gets the current platform
        assert cmd.plat_name == get_platform()

        # build_purelib is build + lib
        wanted = os.path.join(cmd.build_base, 'lib')
        assert cmd.build_purelib == wanted

        # build_platlib is 'build/lib.platform-cache_tag[-pydebug]'
        # examples:
        #   build/lib.macosx-10.3-i386-cpython39
        plat_spec = '.{}-{}'.format(cmd.plat_name, sys.implementation.cache_tag)
        if hasattr(sys, 'gettotalrefcount'):
            assert cmd.build_platlib.endswith('-pydebug')
            plat_spec += '-pydebug'
        wanted = os.path.join(cmd.build_base, 'lib' + plat_spec)
        assert cmd.build_platlib == wanted

        # by default, build_lib = build_purelib
        assert cmd.build_lib == cmd.build_purelib

        # build_temp is build/temp.
        wanted = os.path.join(cmd.build_base, 'temp' + plat_spec)
        assert cmd.build_temp == wanted

        # build_scripts is build/scripts-x.x
        wanted = os.path.join(cmd.build_base, 'scripts-%d.%d' % sys.version_info[:2])
        assert cmd.build_scripts == wanted

        # executable is os.path.normpath(sys.executable)
        assert cmd.executable == os.path.normpath(sys.executable)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_build_clib.py0000644000175100001730000001040414467657412024720 0ustar00runnerdocker"""Tests for distutils.command.build_clib."""
import os

from test.support import missing_compiler_executable

import pytest

from distutils.command.build_clib import build_clib
from distutils.errors import DistutilsSetupError
from distutils.tests import support


class TestBuildCLib(support.TempdirManager):
    def test_check_library_dist(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # 'libraries' option must be a list
        with pytest.raises(DistutilsSetupError):
            cmd.check_library_list('foo')

        # each element of 'libraries' must a 2-tuple
        with pytest.raises(DistutilsSetupError):
            cmd.check_library_list(['foo1', 'foo2'])

        # first element of each tuple in 'libraries'
        # must be a string (the library name)
        with pytest.raises(DistutilsSetupError):
            cmd.check_library_list([(1, 'foo1'), ('name', 'foo2')])

        # library name may not contain directory separators
        with pytest.raises(DistutilsSetupError):
            cmd.check_library_list(
                [('name', 'foo1'), ('another/name', 'foo2')],
            )

        # second element of each tuple must be a dictionary (build info)
        with pytest.raises(DistutilsSetupError):
            cmd.check_library_list(
                [('name', {}), ('another', 'foo2')],
            )

        # those work
        libs = [('name', {}), ('name', {'ok': 'good'})]
        cmd.check_library_list(libs)

    def test_get_source_files(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        # "in 'libraries' option 'sources' must be present and must be
        # a list of source filenames
        cmd.libraries = [('name', {})]
        with pytest.raises(DistutilsSetupError):
            cmd.get_source_files()

        cmd.libraries = [('name', {'sources': 1})]
        with pytest.raises(DistutilsSetupError):
            cmd.get_source_files()

        cmd.libraries = [('name', {'sources': ['a', 'b']})]
        assert cmd.get_source_files() == ['a', 'b']

        cmd.libraries = [('name', {'sources': ('a', 'b')})]
        assert cmd.get_source_files() == ['a', 'b']

        cmd.libraries = [
            ('name', {'sources': ('a', 'b')}),
            ('name2', {'sources': ['c', 'd']}),
        ]
        assert cmd.get_source_files() == ['a', 'b', 'c', 'd']

    def test_build_libraries(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        class FakeCompiler:
            def compile(*args, **kw):
                pass

            create_static_lib = compile

        cmd.compiler = FakeCompiler()

        # build_libraries is also doing a bit of typo checking
        lib = [('name', {'sources': 'notvalid'})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(lib)

        lib = [('name', {'sources': list()})]
        cmd.build_libraries(lib)

        lib = [('name', {'sources': tuple()})]
        cmd.build_libraries(lib)

    def test_finalize_options(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        cmd.include_dirs = 'one-dir'
        cmd.finalize_options()
        assert cmd.include_dirs == ['one-dir']

        cmd.include_dirs = None
        cmd.finalize_options()
        assert cmd.include_dirs == []

        cmd.distribution.libraries = 'WONTWORK'
        with pytest.raises(DistutilsSetupError):
            cmd.finalize_options()

    @pytest.mark.skipif('platform.system() == "Windows"')
    def test_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = build_clib(dist)

        foo_c = os.path.join(pkg_dir, 'foo.c')
        self.write_file(foo_c, 'int main(void) { return 1;}\n')
        cmd.libraries = [('foo', {'sources': [foo_c]})]

        build_temp = os.path.join(pkg_dir, 'build')
        os.mkdir(build_temp)
        cmd.build_temp = build_temp
        cmd.build_clib = build_temp

        # Before we run the command, we want to make sure
        # all commands are present on the system.
        ccmd = missing_compiler_executable()
        if ccmd is not None:
            self.skipTest('The %r command is not found' % ccmd)

        # this should work
        cmd.run()

        # let's check the result
        assert 'libfoo.a' in os.listdir(build_temp)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_build_ext.py0000644000175100001730000004662014467657412024620 0ustar00runnerdockerimport sys
import os
from io import StringIO
import textwrap
import site
import contextlib
import platform
import tempfile
import importlib
import shutil
import re

import path
import pytest

from distutils.core import Distribution
from distutils.command.build_ext import build_ext
from distutils import sysconfig
from distutils.tests.support import (
    TempdirManager,
    copy_xxmodule_c,
    fixup_build_ext,
)
from distutils.extension import Extension
from distutils.errors import (
    CompileError,
    DistutilsPlatformError,
    DistutilsSetupError,
    UnknownFileError,
)

from test import support
from . import py38compat as import_helper


@pytest.fixture()
def user_site_dir(request):
    self = request.instance
    self.tmp_dir = self.mkdtemp()
    from distutils.command import build_ext

    orig_user_base = site.USER_BASE

    site.USER_BASE = self.mkdtemp()
    build_ext.USER_BASE = site.USER_BASE

    # bpo-30132: On Windows, a .pdb file may be created in the current
    # working directory. Create a temporary working directory to cleanup
    # everything at the end of the test.
    with path.Path(self.tmp_dir):
        yield

    site.USER_BASE = orig_user_base
    build_ext.USER_BASE = orig_user_base


@contextlib.contextmanager
def safe_extension_import(name, path):
    with import_helper.CleanImport(name):
        with extension_redirect(name, path) as new_path:
            with import_helper.DirsOnSysPath(new_path):
                yield


@contextlib.contextmanager
def extension_redirect(mod, path):
    """
    Tests will fail to tear down an extension module if it's been imported.

    Before importing, copy the file to a temporary directory that won't
    be cleaned up. Yield the new path.
    """
    if platform.system() != "Windows" and sys.platform != "cygwin":
        yield path
        return
    with import_helper.DirsOnSysPath(path):
        spec = importlib.util.find_spec(mod)
    filename = os.path.basename(spec.origin)
    trash_dir = tempfile.mkdtemp(prefix='deleteme')
    dest = os.path.join(trash_dir, os.path.basename(filename))
    shutil.copy(spec.origin, dest)
    yield trash_dir
    # TODO: can the file be scheduled for deletion?


@pytest.mark.usefixtures('user_site_dir')
class TestBuildExt(TempdirManager):
    def build_ext(self, *args, **kwargs):
        return build_ext(*args, **kwargs)

    def test_build_ext(self):
        cmd = support.missing_compiler_executable()
        copy_xxmodule_c(self.tmp_dir)
        xx_c = os.path.join(self.tmp_dir, 'xxmodule.c')
        xx_ext = Extension('xx', [xx_c])
        dist = Distribution({'name': 'xx', 'ext_modules': [xx_ext]})
        dist.package_dir = self.tmp_dir
        cmd = self.build_ext(dist)
        fixup_build_ext(cmd)
        cmd.build_lib = self.tmp_dir
        cmd.build_temp = self.tmp_dir

        old_stdout = sys.stdout
        if not support.verbose:
            # silence compiler output
            sys.stdout = StringIO()
        try:
            cmd.ensure_finalized()
            cmd.run()
        finally:
            sys.stdout = old_stdout

        with safe_extension_import('xx', self.tmp_dir):
            self._test_xx()

    @staticmethod
    def _test_xx():
        import xx

        for attr in ('error', 'foo', 'new', 'roj'):
            assert hasattr(xx, attr)

        assert xx.foo(2, 5) == 7
        assert xx.foo(13, 15) == 28
        assert xx.new().demo() is None
        if support.HAVE_DOCSTRINGS:
            doc = 'This is a template module just for instruction.'
            assert xx.__doc__ == doc
        assert isinstance(xx.Null(), xx.Null)
        assert isinstance(xx.Str(), xx.Str)

    def test_solaris_enable_shared(self):
        dist = Distribution({'name': 'xx'})
        cmd = self.build_ext(dist)
        old = sys.platform

        sys.platform = 'sunos'  # fooling finalize_options
        from distutils.sysconfig import _config_vars

        old_var = _config_vars.get('Py_ENABLE_SHARED')
        _config_vars['Py_ENABLE_SHARED'] = 1
        try:
            cmd.ensure_finalized()
        finally:
            sys.platform = old
            if old_var is None:
                del _config_vars['Py_ENABLE_SHARED']
            else:
                _config_vars['Py_ENABLE_SHARED'] = old_var

        # make sure we get some library dirs under solaris
        assert len(cmd.library_dirs) > 0

    def test_user_site(self):
        import site

        dist = Distribution({'name': 'xx'})
        cmd = self.build_ext(dist)

        # making sure the user option is there
        options = [name for name, short, label in cmd.user_options]
        assert 'user' in options

        # setting a value
        cmd.user = 1

        # setting user based lib and include
        lib = os.path.join(site.USER_BASE, 'lib')
        incl = os.path.join(site.USER_BASE, 'include')
        os.mkdir(lib)
        os.mkdir(incl)

        # let's run finalize
        cmd.ensure_finalized()

        # see if include_dirs and library_dirs
        # were set
        assert lib in cmd.library_dirs
        assert lib in cmd.rpath
        assert incl in cmd.include_dirs

    def test_optional_extension(self):
        # this extension will fail, but let's ignore this failure
        # with the optional argument.
        modules = [Extension('foo', ['xxx'], optional=False)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        with pytest.raises((UnknownFileError, CompileError)):
            cmd.run()  # should raise an error

        modules = [Extension('foo', ['xxx'], optional=True)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        cmd.run()  # should pass

    def test_finalize_options(self):
        # Make sure Python's include directories (for Python.h, pyconfig.h,
        # etc.) are in the include search path.
        modules = [Extension('foo', ['xxx'], optional=False)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.finalize_options()

        py_include = sysconfig.get_python_inc()
        for p in py_include.split(os.path.pathsep):
            assert p in cmd.include_dirs

        plat_py_include = sysconfig.get_python_inc(plat_specific=1)
        for p in plat_py_include.split(os.path.pathsep):
            assert p in cmd.include_dirs

        # make sure cmd.libraries is turned into a list
        # if it's a string
        cmd = self.build_ext(dist)
        cmd.libraries = 'my_lib, other_lib lastlib'
        cmd.finalize_options()
        assert cmd.libraries == ['my_lib', 'other_lib', 'lastlib']

        # make sure cmd.library_dirs is turned into a list
        # if it's a string
        cmd = self.build_ext(dist)
        cmd.library_dirs = 'my_lib_dir%sother_lib_dir' % os.pathsep
        cmd.finalize_options()
        assert 'my_lib_dir' in cmd.library_dirs
        assert 'other_lib_dir' in cmd.library_dirs

        # make sure rpath is turned into a list
        # if it's a string
        cmd = self.build_ext(dist)
        cmd.rpath = 'one%stwo' % os.pathsep
        cmd.finalize_options()
        assert cmd.rpath == ['one', 'two']

        # make sure cmd.link_objects is turned into a list
        # if it's a string
        cmd = build_ext(dist)
        cmd.link_objects = 'one two,three'
        cmd.finalize_options()
        assert cmd.link_objects == ['one', 'two', 'three']

        # XXX more tests to perform for win32

        # make sure define is turned into 2-tuples
        # strings if they are ','-separated strings
        cmd = self.build_ext(dist)
        cmd.define = 'one,two'
        cmd.finalize_options()
        assert cmd.define == [('one', '1'), ('two', '1')]

        # make sure undef is turned into a list of
        # strings if they are ','-separated strings
        cmd = self.build_ext(dist)
        cmd.undef = 'one,two'
        cmd.finalize_options()
        assert cmd.undef == ['one', 'two']

        # make sure swig_opts is turned into a list
        cmd = self.build_ext(dist)
        cmd.swig_opts = None
        cmd.finalize_options()
        assert cmd.swig_opts == []

        cmd = self.build_ext(dist)
        cmd.swig_opts = '1 2'
        cmd.finalize_options()
        assert cmd.swig_opts == ['1', '2']

    def test_check_extensions_list(self):
        dist = Distribution()
        cmd = self.build_ext(dist)
        cmd.finalize_options()

        # 'extensions' option must be a list of Extension instances
        with pytest.raises(DistutilsSetupError):
            cmd.check_extensions_list('foo')

        # each element of 'ext_modules' option must be an
        # Extension instance or 2-tuple
        exts = [('bar', 'foo', 'bar'), 'foo']
        with pytest.raises(DistutilsSetupError):
            cmd.check_extensions_list(exts)

        # first element of each tuple in 'ext_modules'
        # must be the extension name (a string) and match
        # a python dotted-separated name
        exts = [('foo-bar', '')]
        with pytest.raises(DistutilsSetupError):
            cmd.check_extensions_list(exts)

        # second element of each tuple in 'ext_modules'
        # must be a dictionary (build info)
        exts = [('foo.bar', '')]
        with pytest.raises(DistutilsSetupError):
            cmd.check_extensions_list(exts)

        # ok this one should pass
        exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', 'some': 'bar'})]
        cmd.check_extensions_list(exts)
        ext = exts[0]
        assert isinstance(ext, Extension)

        # check_extensions_list adds in ext the values passed
        # when they are in ('include_dirs', 'library_dirs', 'libraries'
        # 'extra_objects', 'extra_compile_args', 'extra_link_args')
        assert ext.libraries == 'foo'
        assert not hasattr(ext, 'some')

        # 'macros' element of build info dict must be 1- or 2-tuple
        exts = [
            (
                'foo.bar',
                {
                    'sources': [''],
                    'libraries': 'foo',
                    'some': 'bar',
                    'macros': [('1', '2', '3'), 'foo'],
                },
            )
        ]
        with pytest.raises(DistutilsSetupError):
            cmd.check_extensions_list(exts)

        exts[0][1]['macros'] = [('1', '2'), ('3',)]
        cmd.check_extensions_list(exts)
        assert exts[0].undef_macros == ['3']
        assert exts[0].define_macros == [('1', '2')]

    def test_get_source_files(self):
        modules = [Extension('foo', ['xxx'], optional=False)]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        assert cmd.get_source_files() == ['xxx']

    def test_unicode_module_names(self):
        modules = [
            Extension('foo', ['aaa'], optional=False),
            Extension('föö', ['uuu'], optional=False),
        ]
        dist = Distribution({'name': 'xx', 'ext_modules': modules})
        cmd = self.build_ext(dist)
        cmd.ensure_finalized()
        assert re.search(r'foo(_d)?\..*', cmd.get_ext_filename(modules[0].name))
        assert re.search(r'föö(_d)?\..*', cmd.get_ext_filename(modules[1].name))
        assert cmd.get_export_symbols(modules[0]) == ['PyInit_foo']
        assert cmd.get_export_symbols(modules[1]) == ['PyInitU_f_1gaa']

    def test_compiler_option(self):
        # cmd.compiler is an option and
        # should not be overridden by a compiler instance
        # when the command is run
        dist = Distribution()
        cmd = self.build_ext(dist)
        cmd.compiler = 'unix'
        cmd.ensure_finalized()
        cmd.run()
        assert cmd.compiler == 'unix'

    def test_get_outputs(self):
        cmd = support.missing_compiler_executable()
        tmp_dir = self.mkdtemp()
        c_file = os.path.join(tmp_dir, 'foo.c')
        self.write_file(c_file, 'void PyInit_foo(void) {}\n')
        ext = Extension('foo', [c_file], optional=False)
        dist = Distribution({'name': 'xx', 'ext_modules': [ext]})
        cmd = self.build_ext(dist)
        fixup_build_ext(cmd)
        cmd.ensure_finalized()
        assert len(cmd.get_outputs()) == 1

        cmd.build_lib = os.path.join(self.tmp_dir, 'build')
        cmd.build_temp = os.path.join(self.tmp_dir, 'tempt')

        # issue #5977 : distutils build_ext.get_outputs
        # returns wrong result with --inplace
        other_tmp_dir = os.path.realpath(self.mkdtemp())
        old_wd = os.getcwd()
        os.chdir(other_tmp_dir)
        try:
            cmd.inplace = 1
            cmd.run()
            so_file = cmd.get_outputs()[0]
        finally:
            os.chdir(old_wd)
        assert os.path.exists(so_file)
        ext_suffix = sysconfig.get_config_var('EXT_SUFFIX')
        assert so_file.endswith(ext_suffix)
        so_dir = os.path.dirname(so_file)
        assert so_dir == other_tmp_dir

        cmd.inplace = 0
        cmd.compiler = None
        cmd.run()
        so_file = cmd.get_outputs()[0]
        assert os.path.exists(so_file)
        assert so_file.endswith(ext_suffix)
        so_dir = os.path.dirname(so_file)
        assert so_dir == cmd.build_lib

        # inplace = 0, cmd.package = 'bar'
        build_py = cmd.get_finalized_command('build_py')
        build_py.package_dir = {'': 'bar'}
        path = cmd.get_ext_fullpath('foo')
        # checking that the last directory is the build_dir
        path = os.path.split(path)[0]
        assert path == cmd.build_lib

        # inplace = 1, cmd.package = 'bar'
        cmd.inplace = 1
        other_tmp_dir = os.path.realpath(self.mkdtemp())
        old_wd = os.getcwd()
        os.chdir(other_tmp_dir)
        try:
            path = cmd.get_ext_fullpath('foo')
        finally:
            os.chdir(old_wd)
        # checking that the last directory is bar
        path = os.path.split(path)[0]
        lastdir = os.path.split(path)[-1]
        assert lastdir == 'bar'

    def test_ext_fullpath(self):
        ext = sysconfig.get_config_var('EXT_SUFFIX')
        # building lxml.etree inplace
        # etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c')
        # etree_ext = Extension('lxml.etree', [etree_c])
        # dist = Distribution({'name': 'lxml', 'ext_modules': [etree_ext]})
        dist = Distribution()
        cmd = self.build_ext(dist)
        cmd.inplace = 1
        cmd.distribution.package_dir = {'': 'src'}
        cmd.distribution.packages = ['lxml', 'lxml.html']
        curdir = os.getcwd()
        wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext)
        path = cmd.get_ext_fullpath('lxml.etree')
        assert wanted == path

        # building lxml.etree not inplace
        cmd.inplace = 0
        cmd.build_lib = os.path.join(curdir, 'tmpdir')
        wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext)
        path = cmd.get_ext_fullpath('lxml.etree')
        assert wanted == path

        # building twisted.runner.portmap not inplace
        build_py = cmd.get_finalized_command('build_py')
        build_py.package_dir = {}
        cmd.distribution.packages = ['twisted', 'twisted.runner.portmap']
        path = cmd.get_ext_fullpath('twisted.runner.portmap')
        wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext)
        assert wanted == path

        # building twisted.runner.portmap inplace
        cmd.inplace = 1
        path = cmd.get_ext_fullpath('twisted.runner.portmap')
        wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext)
        assert wanted == path

    @pytest.mark.skipif('platform.system() != "Darwin"')
    @pytest.mark.usefixtures('save_env')
    def test_deployment_target_default(self):
        # Issue 9516: Test that, in the absence of the environment variable,
        # an extension module is compiled with the same deployment target as
        #  the interpreter.
        self._try_compile_deployment_target('==', None)

    @pytest.mark.skipif('platform.system() != "Darwin"')
    @pytest.mark.usefixtures('save_env')
    def test_deployment_target_too_low(self):
        # Issue 9516: Test that an extension module is not allowed to be
        # compiled with a deployment target less than that of the interpreter.
        with pytest.raises(DistutilsPlatformError):
            self._try_compile_deployment_target('>', '10.1')

    @pytest.mark.skipif('platform.system() != "Darwin"')
    @pytest.mark.usefixtures('save_env')
    def test_deployment_target_higher_ok(self):
        # Issue 9516: Test that an extension module can be compiled with a
        # deployment target higher than that of the interpreter: the ext
        # module may depend on some newer OS feature.
        deptarget = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
        if deptarget:
            # increment the minor version number (i.e. 10.6 -> 10.7)
            deptarget = [int(x) for x in deptarget.split('.')]
            deptarget[-1] += 1
            deptarget = '.'.join(str(i) for i in deptarget)
            self._try_compile_deployment_target('<', deptarget)

    def _try_compile_deployment_target(self, operator, target):
        if target is None:
            if os.environ.get('MACOSX_DEPLOYMENT_TARGET'):
                del os.environ['MACOSX_DEPLOYMENT_TARGET']
        else:
            os.environ['MACOSX_DEPLOYMENT_TARGET'] = target

        deptarget_c = os.path.join(self.tmp_dir, 'deptargetmodule.c')

        with open(deptarget_c, 'w') as fp:
            fp.write(
                textwrap.dedent(
                    '''\
                #include 

                int dummy;

                #if TARGET %s MAC_OS_X_VERSION_MIN_REQUIRED
                #else
                #error "Unexpected target"
                #endif

            '''
                    % operator
                )
            )

        # get the deployment target that the interpreter was built with
        target = sysconfig.get_config_var('MACOSX_DEPLOYMENT_TARGET')
        target = tuple(map(int, target.split('.')[0:2]))
        # format the target value as defined in the Apple
        # Availability Macros.  We can't use the macro names since
        # at least one value we test with will not exist yet.
        if target[:2] < (10, 10):
            # for 10.1 through 10.9.x -> "10n0"
            target = '%02d%01d0' % target
        else:
            # for 10.10 and beyond -> "10nn00"
            if len(target) >= 2:
                target = '%02d%02d00' % target
            else:
                # 11 and later can have no minor version (11 instead of 11.0)
                target = '%02d0000' % target
        deptarget_ext = Extension(
            'deptarget',
            [deptarget_c],
            extra_compile_args=['-DTARGET={}'.format(target)],
        )
        dist = Distribution({'name': 'deptarget', 'ext_modules': [deptarget_ext]})
        dist.package_dir = self.tmp_dir
        cmd = self.build_ext(dist)
        cmd.build_lib = self.tmp_dir
        cmd.build_temp = self.tmp_dir

        try:
            old_stdout = sys.stdout
            if not support.verbose:
                # silence compiler output
                sys.stdout = StringIO()
            try:
                cmd.ensure_finalized()
                cmd.run()
            finally:
                sys.stdout = old_stdout

        except CompileError:
            self.fail("Wrong deployment target during compilation")


class TestParallelBuildExt(TestBuildExt):
    def build_ext(self, *args, **kwargs):
        build_ext = super().build_ext(*args, **kwargs)
        build_ext.parallel = True
        return build_ext
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_build_py.py0000644000175100001730000001571514467657412024451 0ustar00runnerdocker"""Tests for distutils.command.build_py."""

import os
import sys

import pytest

from distutils.command.build_py import build_py
from distutils.core import Distribution
from distutils.errors import DistutilsFileError

from distutils.tests import support


@support.combine_markers
class TestBuildPy(support.TempdirManager):
    def test_package_data(self):
        sources = self.mkdtemp()
        f = open(os.path.join(sources, "__init__.py"), "w")
        try:
            f.write("# Pretend this is a package.")
        finally:
            f.close()
        f = open(os.path.join(sources, "README.txt"), "w")
        try:
            f.write("Info about this package")
        finally:
            f.close()

        destination = self.mkdtemp()

        dist = Distribution({"packages": ["pkg"], "package_dir": {"pkg": sources}})
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(sources, "setup.py")
        dist.command_obj["build"] = support.DummyCommand(force=0, build_lib=destination)
        dist.packages = ["pkg"]
        dist.package_data = {"pkg": ["README.txt"]}
        dist.package_dir = {"pkg": sources}

        cmd = build_py(dist)
        cmd.compile = 1
        cmd.ensure_finalized()
        assert cmd.package_data == dist.package_data

        cmd.run()

        # This makes sure the list of outputs includes byte-compiled
        # files for Python modules but not for package data files
        # (there shouldn't *be* byte-code files for those!).
        assert len(cmd.get_outputs()) == 3
        pkgdest = os.path.join(destination, "pkg")
        files = os.listdir(pkgdest)
        pycache_dir = os.path.join(pkgdest, "__pycache__")
        assert "__init__.py" in files
        assert "README.txt" in files
        if sys.dont_write_bytecode:
            assert not os.path.exists(pycache_dir)
        else:
            pyc_files = os.listdir(pycache_dir)
            assert "__init__.%s.pyc" % sys.implementation.cache_tag in pyc_files

    def test_empty_package_dir(self):
        # See bugs #1668596/#1720897
        sources = self.mkdtemp()
        open(os.path.join(sources, "__init__.py"), "w").close()

        testdir = os.path.join(sources, "doc")
        os.mkdir(testdir)
        open(os.path.join(testdir, "testfile"), "w").close()

        os.chdir(sources)
        dist = Distribution(
            {
                "packages": ["pkg"],
                "package_dir": {"pkg": ""},
                "package_data": {"pkg": ["doc/*"]},
            }
        )
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(sources, "setup.py")
        dist.script_args = ["build"]
        dist.parse_command_line()

        try:
            dist.run_commands()
        except DistutilsFileError:
            self.fail("failed package_data test when package_dir is ''")

    @pytest.mark.skipif('sys.dont_write_bytecode')
    def test_byte_compile(self):
        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
        os.chdir(project_dir)
        self.write_file('boiledeggs.py', 'import antigravity')
        cmd = build_py(dist)
        cmd.compile = 1
        cmd.build_lib = 'here'
        cmd.finalize_options()
        cmd.run()

        found = os.listdir(cmd.build_lib)
        assert sorted(found) == ['__pycache__', 'boiledeggs.py']
        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
        assert found == ['boiledeggs.%s.pyc' % sys.implementation.cache_tag]

    @pytest.mark.skipif('sys.dont_write_bytecode')
    def test_byte_compile_optimized(self):
        project_dir, dist = self.create_dist(py_modules=['boiledeggs'])
        os.chdir(project_dir)
        self.write_file('boiledeggs.py', 'import antigravity')
        cmd = build_py(dist)
        cmd.compile = 0
        cmd.optimize = 1
        cmd.build_lib = 'here'
        cmd.finalize_options()
        cmd.run()

        found = os.listdir(cmd.build_lib)
        assert sorted(found) == ['__pycache__', 'boiledeggs.py']
        found = os.listdir(os.path.join(cmd.build_lib, '__pycache__'))
        expect = f'boiledeggs.{sys.implementation.cache_tag}.opt-1.pyc'
        assert sorted(found) == [expect]

    def test_dir_in_package_data(self):
        """
        A directory in package_data should not be added to the filelist.
        """
        # See bug 19286
        sources = self.mkdtemp()
        pkg_dir = os.path.join(sources, "pkg")

        os.mkdir(pkg_dir)
        open(os.path.join(pkg_dir, "__init__.py"), "w").close()

        docdir = os.path.join(pkg_dir, "doc")
        os.mkdir(docdir)
        open(os.path.join(docdir, "testfile"), "w").close()

        # create the directory that could be incorrectly detected as a file
        os.mkdir(os.path.join(docdir, 'otherdir'))

        os.chdir(sources)
        dist = Distribution({"packages": ["pkg"], "package_data": {"pkg": ["doc/*"]}})
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(sources, "setup.py")
        dist.script_args = ["build"]
        dist.parse_command_line()

        try:
            dist.run_commands()
        except DistutilsFileError:
            self.fail("failed package_data when data dir includes a dir")

    def test_dont_write_bytecode(self, caplog):
        # makes sure byte_compile is not used
        dist = self.create_dist()[1]
        cmd = build_py(dist)
        cmd.compile = 1
        cmd.optimize = 1

        old_dont_write_bytecode = sys.dont_write_bytecode
        sys.dont_write_bytecode = True
        try:
            cmd.byte_compile([])
        finally:
            sys.dont_write_bytecode = old_dont_write_bytecode

        assert 'byte-compiling is disabled' in caplog.records[0].message

    def test_namespace_package_does_not_warn(self, caplog):
        """
        Originally distutils implementation did not account for PEP 420
        and included warns for package directories that did not contain
        ``__init__.py`` files.
        After the acceptance of PEP 420, these warnings don't make more sense
        so we want to ensure there are not displayed to not confuse the users.
        """
        # Create a fake project structure with a package namespace:
        tmp = self.mkdtemp()
        os.chdir(tmp)
        os.makedirs("ns/pkg")
        open("ns/pkg/module.py", "w").close()

        # Configure the package:
        attrs = {
            "name": "ns.pkg",
            "packages": ["ns", "ns.pkg"],
            "script_name": "setup.py",
        }
        dist = Distribution(attrs)

        # Run code paths that would trigger the trap:
        cmd = dist.get_command_obj("build_py")
        cmd.finalize_options()
        modules = cmd.find_all_modules()
        assert len(modules) == 1
        module_path = modules[0][-1]
        assert module_path.replace(os.sep, "/") == "ns/pkg/module.py"

        cmd.run()

        assert not any(
            "package init file" in msg and "not found" in msg for msg in caplog.messages
        )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_build_scripts.py0000644000175100001730000000600514467657412025500 0ustar00runnerdocker"""Tests for distutils.command.build_scripts."""

import os

from distutils.command.build_scripts import build_scripts
from distutils.core import Distribution
from distutils import sysconfig

from distutils.tests import support


class TestBuildScripts(support.TempdirManager):
    def test_default_settings(self):
        cmd = self.get_build_scripts_cmd("/foo/bar", [])
        assert not cmd.force
        assert cmd.build_dir is None

        cmd.finalize_options()

        assert cmd.force
        assert cmd.build_dir == "/foo/bar"

    def test_build(self):
        source = self.mkdtemp()
        target = self.mkdtemp()
        expected = self.write_sample_scripts(source)

        cmd = self.get_build_scripts_cmd(
            target, [os.path.join(source, fn) for fn in expected]
        )
        cmd.finalize_options()
        cmd.run()

        built = os.listdir(target)
        for name in expected:
            assert name in built

    def get_build_scripts_cmd(self, target, scripts):
        import sys

        dist = Distribution()
        dist.scripts = scripts
        dist.command_obj["build"] = support.DummyCommand(
            build_scripts=target, force=1, executable=sys.executable
        )
        return build_scripts(dist)

    def write_sample_scripts(self, dir):
        expected = []
        expected.append("script1.py")
        self.write_script(
            dir,
            "script1.py",
            (
                "#! /usr/bin/env python2.3\n"
                "# bogus script w/ Python sh-bang\n"
                "pass\n"
            ),
        )
        expected.append("script2.py")
        self.write_script(
            dir,
            "script2.py",
            ("#!/usr/bin/python\n" "# bogus script w/ Python sh-bang\n" "pass\n"),
        )
        expected.append("shell.sh")
        self.write_script(
            dir,
            "shell.sh",
            ("#!/bin/sh\n" "# bogus shell script w/ sh-bang\n" "exit 0\n"),
        )
        return expected

    def write_script(self, dir, name, text):
        f = open(os.path.join(dir, name), "w")
        try:
            f.write(text)
        finally:
            f.close()

    def test_version_int(self):
        source = self.mkdtemp()
        target = self.mkdtemp()
        expected = self.write_sample_scripts(source)

        cmd = self.get_build_scripts_cmd(
            target, [os.path.join(source, fn) for fn in expected]
        )
        cmd.finalize_options()

        # http://bugs.python.org/issue4524
        #
        # On linux-g++-32 with command line `./configure --enable-ipv6
        # --with-suffix=3`, python is compiled okay but the build scripts
        # failed when writing the name of the executable
        old = sysconfig.get_config_vars().get('VERSION')
        sysconfig._config_vars['VERSION'] = 4
        try:
            cmd.run()
        finally:
            if old is not None:
                sysconfig._config_vars['VERSION'] = old

        built = os.listdir(target)
        for name in expected:
            assert name in built
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_ccompiler.py0000644000175100001730000000560314467657412024612 0ustar00runnerdockerimport os
import sys
import platform
import textwrap
import sysconfig

import pytest

from distutils import ccompiler


def _make_strs(paths):
    """
    Convert paths to strings for legacy compatibility.
    """
    if sys.version_info > (3, 8) and platform.system() != "Windows":
        return paths
    return list(map(os.fspath, paths))


@pytest.fixture
def c_file(tmp_path):
    c_file = tmp_path / 'foo.c'
    gen_headers = ('Python.h',)
    is_windows = platform.system() == "Windows"
    plat_headers = ('windows.h',) * is_windows
    all_headers = gen_headers + plat_headers
    headers = '\n'.join(f'#include <{header}>\n' for header in all_headers)
    payload = (
        textwrap.dedent(
            """
        #headers
        void PyInit_foo(void) {}
        """
        )
        .lstrip()
        .replace('#headers', headers)
    )
    c_file.write_text(payload)
    return c_file


def test_set_include_dirs(c_file):
    """
    Extensions should build even if set_include_dirs is invoked.
    In particular, compiler-specific paths should not be overridden.
    """
    compiler = ccompiler.new_compiler()
    python = sysconfig.get_paths()['include']
    compiler.set_include_dirs([python])
    compiler.compile(_make_strs([c_file]))

    # do it again, setting include dirs after any initialization
    compiler.set_include_dirs([python])
    compiler.compile(_make_strs([c_file]))


def test_has_function_prototype():
    # Issue https://github.com/pypa/setuptools/issues/3648
    # Test prototype-generating behavior.

    compiler = ccompiler.new_compiler()

    # Every C implementation should have these.
    assert compiler.has_function('abort')
    assert compiler.has_function('exit')
    with pytest.deprecated_call(match='includes is deprecated'):
        # abort() is a valid expression with the  prototype.
        assert compiler.has_function('abort', includes=['stdlib.h'])
    with pytest.deprecated_call(match='includes is deprecated'):
        # But exit() is not valid with the actual prototype in scope.
        assert not compiler.has_function('exit', includes=['stdlib.h'])
    # And setuptools_does_not_exist is not declared or defined at all.
    assert not compiler.has_function('setuptools_does_not_exist')
    with pytest.deprecated_call(match='includes is deprecated'):
        assert not compiler.has_function(
            'setuptools_does_not_exist', includes=['stdio.h']
        )


def test_include_dirs_after_multiple_compile_calls(c_file):
    """
    Calling compile multiple times should not change the include dirs
    (regression test for setuptools issue #3591).
    """
    compiler = ccompiler.new_compiler()
    python = sysconfig.get_paths()['include']
    compiler.set_include_dirs([python])
    compiler.compile(_make_strs([c_file]))
    assert compiler.include_dirs == [python]
    compiler.compile(_make_strs([c_file]))
    assert compiler.include_dirs == [python]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_check.py0000644000175100001730000001410014467657412023702 0ustar00runnerdocker"""Tests for distutils.command.check."""
import os
import textwrap

import pytest

from distutils.command.check import check
from distutils.tests import support
from distutils.errors import DistutilsSetupError

try:
    import pygments
except ImportError:
    pygments = None


HERE = os.path.dirname(__file__)


@support.combine_markers
class TestCheck(support.TempdirManager):
    def _run(self, metadata=None, cwd=None, **options):
        if metadata is None:
            metadata = {}
        if cwd is not None:
            old_dir = os.getcwd()
            os.chdir(cwd)
        pkg_info, dist = self.create_dist(**metadata)
        cmd = check(dist)
        cmd.initialize_options()
        for name, value in options.items():
            setattr(cmd, name, value)
        cmd.ensure_finalized()
        cmd.run()
        if cwd is not None:
            os.chdir(old_dir)
        return cmd

    def test_check_metadata(self):
        # let's run the command with no metadata at all
        # by default, check is checking the metadata
        # should have some warnings
        cmd = self._run()
        assert cmd._warnings == 1

        # now let's add the required fields
        # and run it again, to make sure we don't get
        # any warning anymore
        metadata = {
            'url': 'xxx',
            'author': 'xxx',
            'author_email': 'xxx',
            'name': 'xxx',
            'version': 'xxx',
        }
        cmd = self._run(metadata)
        assert cmd._warnings == 0

        # now with the strict mode, we should
        # get an error if there are missing metadata
        with pytest.raises(DistutilsSetupError):
            self._run({}, **{'strict': 1})

        # and of course, no error when all metadata are present
        cmd = self._run(metadata, strict=1)
        assert cmd._warnings == 0

        # now a test with non-ASCII characters
        metadata = {
            'url': 'xxx',
            'author': '\u00c9ric',
            'author_email': 'xxx',
            'name': 'xxx',
            'version': 'xxx',
            'description': 'Something about esszet \u00df',
            'long_description': 'More things about esszet \u00df',
        }
        cmd = self._run(metadata)
        assert cmd._warnings == 0

    def test_check_author_maintainer(self):
        for kind in ("author", "maintainer"):
            # ensure no warning when author_email or maintainer_email is given
            # (the spec allows these fields to take the form "Name ")
            metadata = {
                'url': 'xxx',
                kind + '_email': 'Name ',
                'name': 'xxx',
                'version': 'xxx',
            }
            cmd = self._run(metadata)
            assert cmd._warnings == 0

            # the check should not warn if only email is given
            metadata[kind + '_email'] = 'name@email.com'
            cmd = self._run(metadata)
            assert cmd._warnings == 0

            # the check should not warn if only the name is given
            metadata[kind] = "Name"
            del metadata[kind + '_email']
            cmd = self._run(metadata)
            assert cmd._warnings == 0

    def test_check_document(self):
        pytest.importorskip('docutils')
        pkg_info, dist = self.create_dist()
        cmd = check(dist)

        # let's see if it detects broken rest
        broken_rest = 'title\n===\n\ntest'
        msgs = cmd._check_rst_data(broken_rest)
        assert len(msgs) == 1

        # and non-broken rest
        rest = 'title\n=====\n\ntest'
        msgs = cmd._check_rst_data(rest)
        assert len(msgs) == 0

    def test_check_restructuredtext(self):
        pytest.importorskip('docutils')
        # let's see if it detects broken rest in long_description
        broken_rest = 'title\n===\n\ntest'
        pkg_info, dist = self.create_dist(long_description=broken_rest)
        cmd = check(dist)
        cmd.check_restructuredtext()
        assert cmd._warnings == 1

        # let's see if we have an error with strict=1
        metadata = {
            'url': 'xxx',
            'author': 'xxx',
            'author_email': 'xxx',
            'name': 'xxx',
            'version': 'xxx',
            'long_description': broken_rest,
        }
        with pytest.raises(DistutilsSetupError):
            self._run(metadata, **{'strict': 1, 'restructuredtext': 1})

        # and non-broken rest, including a non-ASCII character to test #12114
        metadata['long_description'] = 'title\n=====\n\ntest \u00df'
        cmd = self._run(metadata, strict=1, restructuredtext=1)
        assert cmd._warnings == 0

        # check that includes work to test #31292
        metadata['long_description'] = 'title\n=====\n\n.. include:: includetest.rst'
        cmd = self._run(metadata, cwd=HERE, strict=1, restructuredtext=1)
        assert cmd._warnings == 0

    def test_check_restructuredtext_with_syntax_highlight(self):
        pytest.importorskip('docutils')
        # Don't fail if there is a `code` or `code-block` directive

        example_rst_docs = [
            textwrap.dedent(
                """\
            Here's some code:

            .. code:: python

                def foo():
                    pass
            """
            ),
            textwrap.dedent(
                """\
            Here's some code:

            .. code-block:: python

                def foo():
                    pass
            """
            ),
        ]

        for rest_with_code in example_rst_docs:
            pkg_info, dist = self.create_dist(long_description=rest_with_code)
            cmd = check(dist)
            cmd.check_restructuredtext()
            msgs = cmd._check_rst_data(rest_with_code)
            if pygments is not None:
                assert len(msgs) == 0
            else:
                assert len(msgs) == 1
                assert (
                    str(msgs[0][1])
                    == 'Cannot analyze code. Pygments package not found.'
                )

    def test_check_all(self):
        with pytest.raises(DistutilsSetupError):
            self._run({}, **{'strict': 1, 'restructuredtext': 1})
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_clean.py0000644000175100001730000000233114467657412023712 0ustar00runnerdocker"""Tests for distutils.command.clean."""
import os

from distutils.command.clean import clean
from distutils.tests import support


class TestClean(support.TempdirManager):
    def test_simple_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = clean(dist)

        # let's add some elements clean should remove
        dirs = [
            (d, os.path.join(pkg_dir, d))
            for d in (
                'build_temp',
                'build_lib',
                'bdist_base',
                'build_scripts',
                'build_base',
            )
        ]

        for name, path in dirs:
            os.mkdir(path)
            setattr(cmd, name, path)
            if name == 'build_base':
                continue
            for f in ('one', 'two', 'three'):
                self.write_file(os.path.join(path, f))

        # let's run the command
        cmd.all = 1
        cmd.ensure_finalized()
        cmd.run()

        # make sure the files where removed
        for name, path in dirs:
            assert not os.path.exists(path), '%s was not removed' % path

        # let's run the command again (should spit warnings but succeed)
        cmd.all = 1
        cmd.ensure_finalized()
        cmd.run()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_cmd.py0000644000175100001730000000626214467657412023402 0ustar00runnerdocker"""Tests for distutils.cmd."""
import os

from distutils.cmd import Command
from distutils.dist import Distribution
from distutils.errors import DistutilsOptionError
from distutils import debug
import pytest


class MyCmd(Command):
    def initialize_options(self):
        pass


@pytest.fixture
def cmd(request):
    return MyCmd(Distribution())


class TestCommand:
    def test_ensure_string_list(self, cmd):
        cmd.not_string_list = ['one', 2, 'three']
        cmd.yes_string_list = ['one', 'two', 'three']
        cmd.not_string_list2 = object()
        cmd.yes_string_list2 = 'ok'
        cmd.ensure_string_list('yes_string_list')
        cmd.ensure_string_list('yes_string_list2')

        with pytest.raises(DistutilsOptionError):
            cmd.ensure_string_list('not_string_list')

        with pytest.raises(DistutilsOptionError):
            cmd.ensure_string_list('not_string_list2')

        cmd.option1 = 'ok,dok'
        cmd.ensure_string_list('option1')
        assert cmd.option1 == ['ok', 'dok']

        cmd.option2 = ['xxx', 'www']
        cmd.ensure_string_list('option2')

        cmd.option3 = ['ok', 2]
        with pytest.raises(DistutilsOptionError):
            cmd.ensure_string_list('option3')

    def test_make_file(self, cmd):
        # making sure it raises when infiles is not a string or a list/tuple
        with pytest.raises(TypeError):
            cmd.make_file(infiles=1, outfile='', func='func', args=())

        # making sure execute gets called properly
        def _execute(func, args, exec_msg, level):
            assert exec_msg == 'generating out from in'

        cmd.force = True
        cmd.execute = _execute
        cmd.make_file(infiles='in', outfile='out', func='func', args=())

    def test_dump_options(self, cmd):
        msgs = []

        def _announce(msg, level):
            msgs.append(msg)

        cmd.announce = _announce
        cmd.option1 = 1
        cmd.option2 = 1
        cmd.user_options = [('option1', '', ''), ('option2', '', '')]
        cmd.dump_options()

        wanted = ["command options for 'MyCmd':", '  option1 = 1', '  option2 = 1']
        assert msgs == wanted

    def test_ensure_string(self, cmd):
        cmd.option1 = 'ok'
        cmd.ensure_string('option1')

        cmd.option2 = None
        cmd.ensure_string('option2', 'xxx')
        assert hasattr(cmd, 'option2')

        cmd.option3 = 1
        with pytest.raises(DistutilsOptionError):
            cmd.ensure_string('option3')

    def test_ensure_filename(self, cmd):
        cmd.option1 = __file__
        cmd.ensure_filename('option1')
        cmd.option2 = 'xxx'
        with pytest.raises(DistutilsOptionError):
            cmd.ensure_filename('option2')

    def test_ensure_dirname(self, cmd):
        cmd.option1 = os.path.dirname(__file__) or os.curdir
        cmd.ensure_dirname('option1')
        cmd.option2 = 'xxx'
        with pytest.raises(DistutilsOptionError):
            cmd.ensure_dirname('option2')

    def test_debug_print(self, cmd, capsys, monkeypatch):
        cmd.debug_print('xxx')
        assert capsys.readouterr().out == ''
        monkeypatch.setattr(debug, 'DEBUG', True)
        cmd.debug_print('xxx')
        assert capsys.readouterr().out == 'xxx\n'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_config.py0000644000175100001730000000524514467657412024104 0ustar00runnerdocker"""Tests for distutils.pypirc.pypirc."""
import os

import pytest

from distutils.tests import support

PYPIRC = """\
[distutils]

index-servers =
    server1
    server2
    server3

[server1]
username:me
password:secret

[server2]
username:meagain
password: secret
realm:acme
repository:http://another.pypi/

[server3]
username:cbiggles
password:yh^%#rest-of-my-password
"""

PYPIRC_OLD = """\
[server-login]
username:tarek
password:secret
"""

WANTED = """\
[distutils]
index-servers =
    pypi

[pypi]
username:tarek
password:xxx
"""


@support.combine_markers
@pytest.mark.usefixtures('pypirc')
class BasePyPIRCCommandTestCase(support.TempdirManager):
    pass


class PyPIRCCommandTestCase(BasePyPIRCCommandTestCase):
    def test_server_registration(self):
        # This test makes sure PyPIRCCommand knows how to:
        # 1. handle several sections in .pypirc
        # 2. handle the old format

        # new format
        self.write_file(self.rc, PYPIRC)
        cmd = self._cmd(self.dist)
        config = cmd._read_pypirc()

        config = list(sorted(config.items()))
        waited = [
            ('password', 'secret'),
            ('realm', 'pypi'),
            ('repository', 'https://upload.pypi.org/legacy/'),
            ('server', 'server1'),
            ('username', 'me'),
        ]
        assert config == waited

        # old format
        self.write_file(self.rc, PYPIRC_OLD)
        config = cmd._read_pypirc()
        config = list(sorted(config.items()))
        waited = [
            ('password', 'secret'),
            ('realm', 'pypi'),
            ('repository', 'https://upload.pypi.org/legacy/'),
            ('server', 'server-login'),
            ('username', 'tarek'),
        ]
        assert config == waited

    def test_server_empty_registration(self):
        cmd = self._cmd(self.dist)
        rc = cmd._get_rc_file()
        assert not os.path.exists(rc)
        cmd._store_pypirc('tarek', 'xxx')
        assert os.path.exists(rc)
        f = open(rc)
        try:
            content = f.read()
            assert content == WANTED
        finally:
            f.close()

    def test_config_interpolation(self):
        # using the % character in .pypirc should not raise an error (#20120)
        self.write_file(self.rc, PYPIRC)
        cmd = self._cmd(self.dist)
        cmd.repository = 'server3'
        config = cmd._read_pypirc()

        config = list(sorted(config.items()))
        waited = [
            ('password', 'yh^%#rest-of-my-password'),
            ('realm', 'pypi'),
            ('repository', 'https://upload.pypi.org/legacy/'),
            ('server', 'server3'),
            ('username', 'cbiggles'),
        ]
        assert config == waited
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_config_cmd.py0000644000175100001730000000517114467657412024725 0ustar00runnerdocker"""Tests for distutils.command.config."""
import os
import sys
from test.support import missing_compiler_executable

import pytest

from distutils.command.config import dump_file, config
from distutils.tests import support
from distutils._log import log


@pytest.fixture(autouse=True)
def info_log(request, monkeypatch):
    self = request.instance
    self._logs = []
    monkeypatch.setattr(log, 'info', self._info)


@support.combine_markers
class TestConfig(support.TempdirManager):
    def _info(self, msg, *args):
        for line in msg.splitlines():
            self._logs.append(line)

    def test_dump_file(self):
        this_file = os.path.splitext(__file__)[0] + '.py'
        f = open(this_file)
        try:
            numlines = len(f.readlines())
        finally:
            f.close()

        dump_file(this_file, 'I am the header')
        assert len(self._logs) == numlines + 1

    @pytest.mark.skipif('platform.system() == "Windows"')
    def test_search_cpp(self):
        cmd = missing_compiler_executable(['preprocessor'])
        if cmd is not None:
            self.skipTest('The %r command is not found' % cmd)
        pkg_dir, dist = self.create_dist()
        cmd = config(dist)
        cmd._check_compiler()
        compiler = cmd.compiler
        if sys.platform[:3] == "aix" and "xlc" in compiler.preprocessor[0].lower():
            self.skipTest(
                'xlc: The -E option overrides the -P, -o, and -qsyntaxonly options'
            )

        # simple pattern searches
        match = cmd.search_cpp(pattern='xxx', body='/* xxx */')
        assert match == 0

        match = cmd.search_cpp(pattern='_configtest', body='/* xxx */')
        assert match == 1

    def test_finalize_options(self):
        # finalize_options does a bit of transformation
        # on options
        pkg_dir, dist = self.create_dist()
        cmd = config(dist)
        cmd.include_dirs = 'one%stwo' % os.pathsep
        cmd.libraries = 'one'
        cmd.library_dirs = 'three%sfour' % os.pathsep
        cmd.ensure_finalized()

        assert cmd.include_dirs == ['one', 'two']
        assert cmd.libraries == ['one']
        assert cmd.library_dirs == ['three', 'four']

    def test_clean(self):
        # _clean removes files
        tmp_dir = self.mkdtemp()
        f1 = os.path.join(tmp_dir, 'one')
        f2 = os.path.join(tmp_dir, 'two')

        self.write_file(f1, 'xxx')
        self.write_file(f2, 'xxx')

        for f in (f1, f2):
            assert os.path.exists(f)

        pkg_dir, dist = self.create_dist()
        cmd = config(dist)
        cmd._clean(f1, f2)

        for f in (f1, f2):
            assert not os.path.exists(f)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_core.py0000644000175100001730000000720314467657412023563 0ustar00runnerdocker"""Tests for distutils.core."""

import io
import distutils.core
import os
import sys

import pytest

from distutils.dist import Distribution

# setup script that uses __file__
setup_using___file__ = """\

__file__

from distutils.core import setup
setup()
"""

setup_prints_cwd = """\

import os
print(os.getcwd())

from distutils.core import setup
setup()
"""

setup_does_nothing = """\
from distutils.core import setup
setup()
"""


setup_defines_subclass = """\
from distutils.core import setup
from distutils.command.install import install as _install

class install(_install):
    sub_commands = _install.sub_commands + ['cmd']

setup(cmdclass={'install': install})
"""

setup_within_if_main = """\
from distutils.core import setup

def main():
    return setup(name="setup_within_if_main")

if __name__ == "__main__":
    main()
"""


@pytest.fixture(autouse=True)
def save_stdout(monkeypatch):
    monkeypatch.setattr(sys, 'stdout', sys.stdout)


@pytest.fixture
def temp_file(tmp_path):
    return tmp_path / 'file'


@pytest.mark.usefixtures('save_env')
@pytest.mark.usefixtures('save_argv')
class TestCore:
    def test_run_setup_provides_file(self, temp_file):
        # Make sure the script can use __file__; if that's missing, the test
        # setup.py script will raise NameError.
        temp_file.write_text(setup_using___file__)
        distutils.core.run_setup(temp_file)

    def test_run_setup_preserves_sys_argv(self, temp_file):
        # Make sure run_setup does not clobber sys.argv
        argv_copy = sys.argv.copy()
        temp_file.write_text(setup_does_nothing)
        distutils.core.run_setup(temp_file)
        assert sys.argv == argv_copy

    def test_run_setup_defines_subclass(self, temp_file):
        # Make sure the script can use __file__; if that's missing, the test
        # setup.py script will raise NameError.
        temp_file.write_text(setup_defines_subclass)
        dist = distutils.core.run_setup(temp_file)
        install = dist.get_command_obj('install')
        assert 'cmd' in install.sub_commands

    def test_run_setup_uses_current_dir(self, tmp_path):
        """
        Test that the setup script is run with the current directory
        as its own current directory.
        """
        sys.stdout = io.StringIO()
        cwd = os.getcwd()

        # Create a directory and write the setup.py file there:
        setup_py = tmp_path / 'setup.py'
        setup_py.write_text(setup_prints_cwd)
        distutils.core.run_setup(setup_py)

        output = sys.stdout.getvalue()
        if output.endswith("\n"):
            output = output[:-1]
        assert cwd == output

    def test_run_setup_within_if_main(self, temp_file):
        temp_file.write_text(setup_within_if_main)
        dist = distutils.core.run_setup(temp_file, stop_after="config")
        assert isinstance(dist, Distribution)
        assert dist.get_name() == "setup_within_if_main"

    def test_run_commands(self, temp_file):
        sys.argv = ['setup.py', 'build']
        temp_file.write_text(setup_within_if_main)
        dist = distutils.core.run_setup(temp_file, stop_after="commandline")
        assert 'build' not in dist.have_run
        distutils.core.run_commands(dist)
        assert 'build' in dist.have_run

    def test_debug_mode(self, capsys, monkeypatch):
        # this covers the code called when DEBUG is set
        sys.argv = ['setup.py', '--name']
        distutils.core.setup(name='bar')
        capsys.readouterr().out == 'bar\n'
        monkeypatch.setattr(distutils.core, 'DEBUG', True)
        distutils.core.setup(name='bar')
        wanted = "options (after parsing config files):\n"
        assert capsys.readouterr().out.startswith(wanted)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_cygwinccompiler.py0000644000175100001730000000736414467657412026041 0ustar00runnerdocker"""Tests for distutils.cygwinccompiler."""
import sys
import os

import pytest

from distutils.cygwinccompiler import (
    check_config_h,
    CONFIG_H_OK,
    CONFIG_H_NOTOK,
    CONFIG_H_UNCERTAIN,
    get_msvcr,
)
from distutils.tests import support
from distutils import sysconfig


@pytest.fixture(autouse=True)
def stuff(request, monkeypatch, distutils_managed_tempdir):
    self = request.instance
    self.python_h = os.path.join(self.mkdtemp(), 'python.h')
    monkeypatch.setattr(sysconfig, 'get_config_h_filename', self._get_config_h_filename)
    monkeypatch.setattr(sys, 'version', sys.version)


class TestCygwinCCompiler(support.TempdirManager):
    def _get_config_h_filename(self):
        return self.python_h

    @pytest.mark.skipif('sys.platform != "cygwin"')
    @pytest.mark.skipif('not os.path.exists("/usr/lib/libbash.dll.a")')
    def test_find_library_file(self):
        from distutils.cygwinccompiler import CygwinCCompiler

        compiler = CygwinCCompiler()
        link_name = "bash"
        linkable_file = compiler.find_library_file(["/usr/lib"], link_name)
        assert linkable_file is not None
        assert os.path.exists(linkable_file)
        assert linkable_file == f"/usr/lib/lib{link_name:s}.dll.a"

    @pytest.mark.skipif('sys.platform != "cygwin"')
    def test_runtime_library_dir_option(self):
        from distutils.cygwinccompiler import CygwinCCompiler

        compiler = CygwinCCompiler()
        assert compiler.runtime_library_dir_option('/foo') == []

    def test_check_config_h(self):
        # check_config_h looks for "GCC" in sys.version first
        # returns CONFIG_H_OK if found
        sys.version = (
            '2.6.1 (r261:67515, Dec  6 2008, 16:42:21) \n[GCC '
            '4.0.1 (Apple Computer, Inc. build 5370)]'
        )

        assert check_config_h()[0] == CONFIG_H_OK

        # then it tries to see if it can find "__GNUC__" in pyconfig.h
        sys.version = 'something without the *CC word'

        # if the file doesn't exist it returns  CONFIG_H_UNCERTAIN
        assert check_config_h()[0] == CONFIG_H_UNCERTAIN

        # if it exists but does not contain __GNUC__, it returns CONFIG_H_NOTOK
        self.write_file(self.python_h, 'xxx')
        assert check_config_h()[0] == CONFIG_H_NOTOK

        # and CONFIG_H_OK if __GNUC__ is found
        self.write_file(self.python_h, 'xxx __GNUC__ xxx')
        assert check_config_h()[0] == CONFIG_H_OK

    def test_get_msvcr(self):
        # none
        sys.version = (
            '2.6.1 (r261:67515, Dec  6 2008, 16:42:21) '
            '\n[GCC 4.0.1 (Apple Computer, Inc. build 5370)]'
        )
        assert get_msvcr() is None

        # MSVC 7.0
        sys.version = (
            '2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1300 32 bits (Intel)]'
        )
        assert get_msvcr() == ['msvcr70']

        # MSVC 7.1
        sys.version = (
            '2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1310 32 bits (Intel)]'
        )
        assert get_msvcr() == ['msvcr71']

        # VS2005 / MSVC 8.0
        sys.version = (
            '2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1400 32 bits (Intel)]'
        )
        assert get_msvcr() == ['msvcr80']

        # VS2008 / MSVC 9.0
        sys.version = (
            '2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.1500 32 bits (Intel)]'
        )
        assert get_msvcr() == ['msvcr90']

        sys.version = (
            '3.10.0 (tags/v3.10.0:b494f59, Oct  4 2021, 18:46:30) '
            '[MSC v.1929 32 bit (Intel)]'
        )
        assert get_msvcr() == ['vcruntime140']

        # unknown
        sys.version = (
            '2.5.1 (r251:54863, Apr 18 2007, 08:51:08) ' '[MSC v.2000 32 bits (Intel)]'
        )
        with pytest.raises(ValueError):
            get_msvcr()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_dep_util.py0000644000175100001730000000466714467657412024453 0ustar00runnerdocker"""Tests for distutils.dep_util."""
import os

from distutils.dep_util import newer, newer_pairwise, newer_group
from distutils.errors import DistutilsFileError
from distutils.tests import support
import pytest


class TestDepUtil(support.TempdirManager):
    def test_newer(self):
        tmpdir = self.mkdtemp()
        new_file = os.path.join(tmpdir, 'new')
        old_file = os.path.abspath(__file__)

        # Raise DistutilsFileError if 'new_file' does not exist.
        with pytest.raises(DistutilsFileError):
            newer(new_file, old_file)

        # Return true if 'new_file' exists and is more recently modified than
        # 'old_file', or if 'new_file' exists and 'old_file' doesn't.
        self.write_file(new_file)
        assert newer(new_file, 'I_dont_exist')
        assert newer(new_file, old_file)

        # Return false if both exist and 'old_file' is the same age or younger
        # than 'new_file'.
        assert not newer(old_file, new_file)

    def test_newer_pairwise(self):
        tmpdir = self.mkdtemp()
        sources = os.path.join(tmpdir, 'sources')
        targets = os.path.join(tmpdir, 'targets')
        os.mkdir(sources)
        os.mkdir(targets)
        one = os.path.join(sources, 'one')
        two = os.path.join(sources, 'two')
        three = os.path.abspath(__file__)  # I am the old file
        four = os.path.join(targets, 'four')
        self.write_file(one)
        self.write_file(two)
        self.write_file(four)

        assert newer_pairwise([one, two], [three, four]) == ([one], [three])

    def test_newer_group(self):
        tmpdir = self.mkdtemp()
        sources = os.path.join(tmpdir, 'sources')
        os.mkdir(sources)
        one = os.path.join(sources, 'one')
        two = os.path.join(sources, 'two')
        three = os.path.join(sources, 'three')
        old_file = os.path.abspath(__file__)

        # return true if 'old_file' is out-of-date with respect to any file
        # listed in 'sources'.
        self.write_file(one)
        self.write_file(two)
        self.write_file(three)
        assert newer_group([one, two, three], old_file)
        assert not newer_group([one, two, old_file], three)

        # missing handling
        os.remove(one)
        with pytest.raises(OSError):
            newer_group([one, two, old_file], three)

        assert not newer_group([one, two, old_file], three, missing='ignore')

        assert newer_group([one, two, old_file], three, missing='newer')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_dir_util.py0000644000175100001730000000752114467657412024451 0ustar00runnerdocker"""Tests for distutils.dir_util."""
import os
import stat
import unittest.mock as mock

from distutils import dir_util, errors
from distutils.dir_util import (
    mkpath,
    remove_tree,
    create_tree,
    copy_tree,
    ensure_relative,
)

from distutils.tests import support
import pytest


@pytest.fixture(autouse=True)
def stuff(request, monkeypatch, distutils_managed_tempdir):
    self = request.instance
    tmp_dir = self.mkdtemp()
    self.root_target = os.path.join(tmp_dir, 'deep')
    self.target = os.path.join(self.root_target, 'here')
    self.target2 = os.path.join(tmp_dir, 'deep2')


class TestDirUtil(support.TempdirManager):
    def test_mkpath_remove_tree_verbosity(self, caplog):
        mkpath(self.target, verbose=0)
        assert not caplog.records
        remove_tree(self.root_target, verbose=0)

        mkpath(self.target, verbose=1)
        wanted = ['creating %s' % self.root_target, 'creating %s' % self.target]
        assert caplog.messages == wanted
        caplog.clear()

        remove_tree(self.root_target, verbose=1)
        wanted = ["removing '%s' (and everything under it)" % self.root_target]
        assert caplog.messages == wanted

    @pytest.mark.skipif("platform.system() == 'Windows'")
    def test_mkpath_with_custom_mode(self):
        # Get and set the current umask value for testing mode bits.
        umask = os.umask(0o002)
        os.umask(umask)
        mkpath(self.target, 0o700)
        assert stat.S_IMODE(os.stat(self.target).st_mode) == 0o700 & ~umask
        mkpath(self.target2, 0o555)
        assert stat.S_IMODE(os.stat(self.target2).st_mode) == 0o555 & ~umask

    def test_create_tree_verbosity(self, caplog):
        create_tree(self.root_target, ['one', 'two', 'three'], verbose=0)
        assert caplog.messages == []
        remove_tree(self.root_target, verbose=0)

        wanted = ['creating %s' % self.root_target]
        create_tree(self.root_target, ['one', 'two', 'three'], verbose=1)
        assert caplog.messages == wanted

        remove_tree(self.root_target, verbose=0)

    def test_copy_tree_verbosity(self, caplog):
        mkpath(self.target, verbose=0)

        copy_tree(self.target, self.target2, verbose=0)
        assert caplog.messages == []

        remove_tree(self.root_target, verbose=0)

        mkpath(self.target, verbose=0)
        a_file = os.path.join(self.target, 'ok.txt')
        with open(a_file, 'w') as f:
            f.write('some content')

        wanted = ['copying {} -> {}'.format(a_file, self.target2)]
        copy_tree(self.target, self.target2, verbose=1)
        assert caplog.messages == wanted

        remove_tree(self.root_target, verbose=0)
        remove_tree(self.target2, verbose=0)

    def test_copy_tree_skips_nfs_temp_files(self):
        mkpath(self.target, verbose=0)

        a_file = os.path.join(self.target, 'ok.txt')
        nfs_file = os.path.join(self.target, '.nfs123abc')
        for f in a_file, nfs_file:
            with open(f, 'w') as fh:
                fh.write('some content')

        copy_tree(self.target, self.target2)
        assert os.listdir(self.target2) == ['ok.txt']

        remove_tree(self.root_target, verbose=0)
        remove_tree(self.target2, verbose=0)

    def test_ensure_relative(self):
        if os.sep == '/':
            assert ensure_relative('/home/foo') == 'home/foo'
            assert ensure_relative('some/path') == 'some/path'
        else:  # \\
            assert ensure_relative('c:\\home\\foo') == 'c:home\\foo'
            assert ensure_relative('home\\foo') == 'home\\foo'

    def test_copy_tree_exception_in_listdir(self):
        """
        An exception in listdir should raise a DistutilsFileError
        """
        with mock.patch("os.listdir", side_effect=OSError()), pytest.raises(
            errors.DistutilsFileError
        ):
            src = self.tempdirs[-1]
            dir_util.copy_tree(src, None)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_dist.py0000644000175100001730000004134114467657412023577 0ustar00runnerdocker"""Tests for distutils.dist."""
import os
import io
import sys
import warnings
import textwrap
import functools
import unittest.mock as mock

import pytest
import jaraco.path

from distutils.dist import Distribution, fix_help_options
from distutils.cmd import Command

from distutils.tests import support


pydistutils_cfg = '.' * (os.name == 'posix') + 'pydistutils.cfg'


class test_dist(Command):
    """Sample distutils extension command."""

    user_options = [
        ("sample-option=", "S", "help text"),
    ]

    def initialize_options(self):
        self.sample_option = None


class TestDistribution(Distribution):
    """Distribution subclasses that avoids the default search for
    configuration files.

    The ._config_files attribute must be set before
    .parse_config_files() is called.
    """

    def find_config_files(self):
        return self._config_files


@pytest.fixture
def clear_argv():
    del sys.argv[1:]


@support.combine_markers
@pytest.mark.usefixtures('save_env')
@pytest.mark.usefixtures('save_argv')
class TestDistributionBehavior(support.TempdirManager):
    def create_distribution(self, configfiles=()):
        d = TestDistribution()
        d._config_files = configfiles
        d.parse_config_files()
        d.parse_command_line()
        return d

    def test_command_packages_unspecified(self, clear_argv):
        sys.argv.append("build")
        d = self.create_distribution()
        assert d.get_command_packages() == ["distutils.command"]

    def test_command_packages_cmdline(self, clear_argv):
        from distutils.tests.test_dist import test_dist

        sys.argv.extend(
            [
                "--command-packages",
                "foo.bar,distutils.tests",
                "test_dist",
                "-Ssometext",
            ]
        )
        d = self.create_distribution()
        # let's actually try to load our test command:
        assert d.get_command_packages() == [
            "distutils.command",
            "foo.bar",
            "distutils.tests",
        ]
        cmd = d.get_command_obj("test_dist")
        assert isinstance(cmd, test_dist)
        assert cmd.sample_option == "sometext"

    @pytest.mark.skipif(
        'distutils' not in Distribution.parse_config_files.__module__,
        reason='Cannot test when virtualenv has monkey-patched Distribution',
    )
    def test_venv_install_options(self, tmp_path):
        sys.argv.append("install")
        file = str(tmp_path / 'file')

        fakepath = '/somedir'

        jaraco.path.build(
            {
                file: f"""
                    [install]
                    install-base = {fakepath}
                    install-platbase = {fakepath}
                    install-lib = {fakepath}
                    install-platlib = {fakepath}
                    install-purelib = {fakepath}
                    install-headers = {fakepath}
                    install-scripts = {fakepath}
                    install-data = {fakepath}
                    prefix = {fakepath}
                    exec-prefix = {fakepath}
                    home = {fakepath}
                    user = {fakepath}
                    root = {fakepath}
                    """,
            }
        )

        # Base case: Not in a Virtual Environment
        with mock.patch.multiple(sys, prefix='/a', base_prefix='/a'):
            d = self.create_distribution([file])

        option_tuple = (file, fakepath)

        result_dict = {
            'install_base': option_tuple,
            'install_platbase': option_tuple,
            'install_lib': option_tuple,
            'install_platlib': option_tuple,
            'install_purelib': option_tuple,
            'install_headers': option_tuple,
            'install_scripts': option_tuple,
            'install_data': option_tuple,
            'prefix': option_tuple,
            'exec_prefix': option_tuple,
            'home': option_tuple,
            'user': option_tuple,
            'root': option_tuple,
        }

        assert sorted(d.command_options.get('install').keys()) == sorted(
            result_dict.keys()
        )

        for key, value in d.command_options.get('install').items():
            assert value == result_dict[key]

        # Test case: In a Virtual Environment
        with mock.patch.multiple(sys, prefix='/a', base_prefix='/b'):
            d = self.create_distribution([file])

        for key in result_dict.keys():
            assert key not in d.command_options.get('install', {})

    def test_command_packages_configfile(self, tmp_path, clear_argv):
        sys.argv.append("build")
        file = str(tmp_path / "file")
        jaraco.path.build(
            {
                file: """
                    [global]
                    command_packages = foo.bar, splat
                    """,
            }
        )

        d = self.create_distribution([file])
        assert d.get_command_packages() == ["distutils.command", "foo.bar", "splat"]

        # ensure command line overrides config:
        sys.argv[1:] = ["--command-packages", "spork", "build"]
        d = self.create_distribution([file])
        assert d.get_command_packages() == ["distutils.command", "spork"]

        # Setting --command-packages to '' should cause the default to
        # be used even if a config file specified something else:
        sys.argv[1:] = ["--command-packages", "", "build"]
        d = self.create_distribution([file])
        assert d.get_command_packages() == ["distutils.command"]

    def test_empty_options(self, request):
        # an empty options dictionary should not stay in the
        # list of attributes

        # catching warnings
        warns = []

        def _warn(msg):
            warns.append(msg)

        request.addfinalizer(
            functools.partial(setattr, warnings, 'warn', warnings.warn)
        )
        warnings.warn = _warn
        dist = Distribution(
            attrs={
                'author': 'xxx',
                'name': 'xxx',
                'version': 'xxx',
                'url': 'xxxx',
                'options': {},
            }
        )

        assert len(warns) == 0
        assert 'options' not in dir(dist)

    def test_finalize_options(self):
        attrs = {'keywords': 'one,two', 'platforms': 'one,two'}

        dist = Distribution(attrs=attrs)
        dist.finalize_options()

        # finalize_option splits platforms and keywords
        assert dist.metadata.platforms == ['one', 'two']
        assert dist.metadata.keywords == ['one', 'two']

        attrs = {'keywords': 'foo bar', 'platforms': 'foo bar'}
        dist = Distribution(attrs=attrs)
        dist.finalize_options()
        assert dist.metadata.platforms == ['foo bar']
        assert dist.metadata.keywords == ['foo bar']

    def test_get_command_packages(self):
        dist = Distribution()
        assert dist.command_packages is None
        cmds = dist.get_command_packages()
        assert cmds == ['distutils.command']
        assert dist.command_packages == ['distutils.command']

        dist.command_packages = 'one,two'
        cmds = dist.get_command_packages()
        assert cmds == ['distutils.command', 'one', 'two']

    def test_announce(self):
        # make sure the level is known
        dist = Distribution()
        with pytest.raises(TypeError):
            dist.announce('ok', level='ok2')

    def test_find_config_files_disable(self, temp_home):
        # Ticket #1180: Allow user to disable their home config file.
        jaraco.path.build({pydistutils_cfg: '[distutils]\n'}, temp_home)

        d = Distribution()
        all_files = d.find_config_files()

        d = Distribution(attrs={'script_args': ['--no-user-cfg']})
        files = d.find_config_files()

        # make sure --no-user-cfg disables the user cfg file
        assert len(all_files) - 1 == len(files)

    @pytest.mark.skipif(
        'platform.system() == "Windows"',
        reason='Windows does not honor chmod 000',
    )
    def test_find_config_files_permission_error(self, fake_home):
        """
        Finding config files should not fail when directory is inaccessible.
        """
        fake_home.joinpath(pydistutils_cfg).write_text('')
        fake_home.chmod(0o000)
        Distribution().find_config_files()


@pytest.mark.usefixtures('save_env')
@pytest.mark.usefixtures('save_argv')
class TestMetadata(support.TempdirManager):
    def format_metadata(self, dist):
        sio = io.StringIO()
        dist.metadata.write_pkg_file(sio)
        return sio.getvalue()

    def test_simple_metadata(self):
        attrs = {"name": "package", "version": "1.0"}
        dist = Distribution(attrs)
        meta = self.format_metadata(dist)
        assert "Metadata-Version: 1.0" in meta
        assert "provides:" not in meta.lower()
        assert "requires:" not in meta.lower()
        assert "obsoletes:" not in meta.lower()

    def test_provides(self):
        attrs = {
            "name": "package",
            "version": "1.0",
            "provides": ["package", "package.sub"],
        }
        dist = Distribution(attrs)
        assert dist.metadata.get_provides() == ["package", "package.sub"]
        assert dist.get_provides() == ["package", "package.sub"]
        meta = self.format_metadata(dist)
        assert "Metadata-Version: 1.1" in meta
        assert "requires:" not in meta.lower()
        assert "obsoletes:" not in meta.lower()

    def test_provides_illegal(self):
        with pytest.raises(ValueError):
            Distribution(
                {"name": "package", "version": "1.0", "provides": ["my.pkg (splat)"]},
            )

    def test_requires(self):
        attrs = {
            "name": "package",
            "version": "1.0",
            "requires": ["other", "another (==1.0)"],
        }
        dist = Distribution(attrs)
        assert dist.metadata.get_requires() == ["other", "another (==1.0)"]
        assert dist.get_requires() == ["other", "another (==1.0)"]
        meta = self.format_metadata(dist)
        assert "Metadata-Version: 1.1" in meta
        assert "provides:" not in meta.lower()
        assert "Requires: other" in meta
        assert "Requires: another (==1.0)" in meta
        assert "obsoletes:" not in meta.lower()

    def test_requires_illegal(self):
        with pytest.raises(ValueError):
            Distribution(
                {"name": "package", "version": "1.0", "requires": ["my.pkg (splat)"]},
            )

    def test_requires_to_list(self):
        attrs = {"name": "package", "requires": iter(["other"])}
        dist = Distribution(attrs)
        assert isinstance(dist.metadata.requires, list)

    def test_obsoletes(self):
        attrs = {
            "name": "package",
            "version": "1.0",
            "obsoletes": ["other", "another (<1.0)"],
        }
        dist = Distribution(attrs)
        assert dist.metadata.get_obsoletes() == ["other", "another (<1.0)"]
        assert dist.get_obsoletes() == ["other", "another (<1.0)"]
        meta = self.format_metadata(dist)
        assert "Metadata-Version: 1.1" in meta
        assert "provides:" not in meta.lower()
        assert "requires:" not in meta.lower()
        assert "Obsoletes: other" in meta
        assert "Obsoletes: another (<1.0)" in meta

    def test_obsoletes_illegal(self):
        with pytest.raises(ValueError):
            Distribution(
                {"name": "package", "version": "1.0", "obsoletes": ["my.pkg (splat)"]},
            )

    def test_obsoletes_to_list(self):
        attrs = {"name": "package", "obsoletes": iter(["other"])}
        dist = Distribution(attrs)
        assert isinstance(dist.metadata.obsoletes, list)

    def test_classifier(self):
        attrs = {
            'name': 'Boa',
            'version': '3.0',
            'classifiers': ['Programming Language :: Python :: 3'],
        }
        dist = Distribution(attrs)
        assert dist.get_classifiers() == ['Programming Language :: Python :: 3']
        meta = self.format_metadata(dist)
        assert 'Metadata-Version: 1.1' in meta

    def test_classifier_invalid_type(self, caplog):
        attrs = {
            'name': 'Boa',
            'version': '3.0',
            'classifiers': ('Programming Language :: Python :: 3',),
        }
        d = Distribution(attrs)
        # should have warning about passing a non-list
        assert 'should be a list' in caplog.messages[0]
        # should be converted to a list
        assert isinstance(d.metadata.classifiers, list)
        assert d.metadata.classifiers == list(attrs['classifiers'])

    def test_keywords(self):
        attrs = {
            'name': 'Monty',
            'version': '1.0',
            'keywords': ['spam', 'eggs', 'life of brian'],
        }
        dist = Distribution(attrs)
        assert dist.get_keywords() == ['spam', 'eggs', 'life of brian']

    def test_keywords_invalid_type(self, caplog):
        attrs = {
            'name': 'Monty',
            'version': '1.0',
            'keywords': ('spam', 'eggs', 'life of brian'),
        }
        d = Distribution(attrs)
        # should have warning about passing a non-list
        assert 'should be a list' in caplog.messages[0]
        # should be converted to a list
        assert isinstance(d.metadata.keywords, list)
        assert d.metadata.keywords == list(attrs['keywords'])

    def test_platforms(self):
        attrs = {
            'name': 'Monty',
            'version': '1.0',
            'platforms': ['GNU/Linux', 'Some Evil Platform'],
        }
        dist = Distribution(attrs)
        assert dist.get_platforms() == ['GNU/Linux', 'Some Evil Platform']

    def test_platforms_invalid_types(self, caplog):
        attrs = {
            'name': 'Monty',
            'version': '1.0',
            'platforms': ('GNU/Linux', 'Some Evil Platform'),
        }
        d = Distribution(attrs)
        # should have warning about passing a non-list
        assert 'should be a list' in caplog.messages[0]
        # should be converted to a list
        assert isinstance(d.metadata.platforms, list)
        assert d.metadata.platforms == list(attrs['platforms'])

    def test_download_url(self):
        attrs = {
            'name': 'Boa',
            'version': '3.0',
            'download_url': 'http://example.org/boa',
        }
        dist = Distribution(attrs)
        meta = self.format_metadata(dist)
        assert 'Metadata-Version: 1.1' in meta

    def test_long_description(self):
        long_desc = textwrap.dedent(
            """\
        example::
              We start here
            and continue here
          and end here."""
        )
        attrs = {"name": "package", "version": "1.0", "long_description": long_desc}

        dist = Distribution(attrs)
        meta = self.format_metadata(dist)
        meta = meta.replace('\n' + 8 * ' ', '\n')
        assert long_desc in meta

    def test_custom_pydistutils(self, temp_home):
        """
        pydistutils.cfg is found
        """
        jaraco.path.build({pydistutils_cfg: ''}, temp_home)
        config_path = temp_home / pydistutils_cfg

        assert str(config_path) in Distribution().find_config_files()

    def test_extra_pydistutils(self, monkeypatch, tmp_path):
        jaraco.path.build({'overrides.cfg': ''}, tmp_path)
        filename = tmp_path / 'overrides.cfg'
        monkeypatch.setenv('DIST_EXTRA_CONFIG', str(filename))
        assert str(filename) in Distribution().find_config_files()

    def test_fix_help_options(self):
        help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)]
        fancy_options = fix_help_options(help_tuples)
        assert fancy_options[0] == ('a', 'b', 'c')
        assert fancy_options[1] == (1, 2, 3)

    def test_show_help(self, request, capsys):
        # smoke test, just makes sure some help is displayed
        dist = Distribution()
        sys.argv = []
        dist.help = 1
        dist.script_name = 'setup.py'
        dist.parse_command_line()

        output = [
            line for line in capsys.readouterr().out.split('\n') if line.strip() != ''
        ]
        assert output

    def test_read_metadata(self):
        attrs = {
            "name": "package",
            "version": "1.0",
            "long_description": "desc",
            "description": "xxx",
            "download_url": "http://example.com",
            "keywords": ['one', 'two'],
            "requires": ['foo'],
        }

        dist = Distribution(attrs)
        metadata = dist.metadata

        # write it then reloads it
        PKG_INFO = io.StringIO()
        metadata.write_pkg_file(PKG_INFO)
        PKG_INFO.seek(0)
        metadata.read_pkg_file(PKG_INFO)

        assert metadata.name == "package"
        assert metadata.version == "1.0"
        assert metadata.description == "xxx"
        assert metadata.download_url == 'http://example.com'
        assert metadata.keywords == ['one', 'two']
        assert metadata.platforms is None
        assert metadata.obsoletes is None
        assert metadata.requires == ['foo']
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_extension.py0000644000175100001730000000556014467657412024653 0ustar00runnerdocker"""Tests for distutils.extension."""
import os
import warnings

from distutils.extension import read_setup_file, Extension

from .py38compat import check_warnings
import pytest


class TestExtension:
    def test_read_setup_file(self):
        # trying to read a Setup file
        # (sample extracted from the PyGame project)
        setup = os.path.join(os.path.dirname(__file__), 'Setup.sample')

        exts = read_setup_file(setup)
        names = [ext.name for ext in exts]
        names.sort()

        # here are the extensions read_setup_file should have created
        # out of the file
        wanted = [
            '_arraysurfarray',
            '_camera',
            '_numericsndarray',
            '_numericsurfarray',
            'base',
            'bufferproxy',
            'cdrom',
            'color',
            'constants',
            'display',
            'draw',
            'event',
            'fastevent',
            'font',
            'gfxdraw',
            'image',
            'imageext',
            'joystick',
            'key',
            'mask',
            'mixer',
            'mixer_music',
            'mouse',
            'movie',
            'overlay',
            'pixelarray',
            'pypm',
            'rect',
            'rwobject',
            'scrap',
            'surface',
            'surflock',
            'time',
            'transform',
        ]

        assert names == wanted

    def test_extension_init(self):
        # the first argument, which is the name, must be a string
        with pytest.raises(AssertionError):
            Extension(1, [])
        ext = Extension('name', [])
        assert ext.name == 'name'

        # the second argument, which is the list of files, must
        # be a list of strings
        with pytest.raises(AssertionError):
            Extension('name', 'file')
        with pytest.raises(AssertionError):
            Extension('name', ['file', 1])
        ext = Extension('name', ['file1', 'file2'])
        assert ext.sources == ['file1', 'file2']

        # others arguments have defaults
        for attr in (
            'include_dirs',
            'define_macros',
            'undef_macros',
            'library_dirs',
            'libraries',
            'runtime_library_dirs',
            'extra_objects',
            'extra_compile_args',
            'extra_link_args',
            'export_symbols',
            'swig_opts',
            'depends',
        ):
            assert getattr(ext, attr) == []

        assert ext.language is None
        assert ext.optional is None

        # if there are unknown keyword options, warn about them
        with check_warnings() as w:
            warnings.simplefilter('always')
            ext = Extension('name', ['file1', 'file2'], chic=True)

        assert len(w.warnings) == 1
        assert str(w.warnings[0].message) == "Unknown Extension options: 'chic'"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_file_util.py0000644000175100001730000000742114467657412024611 0ustar00runnerdocker"""Tests for distutils.file_util."""
import os
import errno
import unittest.mock as mock

from distutils.file_util import move_file, copy_file
from distutils.tests import support
from distutils.errors import DistutilsFileError
from .py38compat import unlink
import pytest


@pytest.fixture(autouse=True)
def stuff(request, monkeypatch, distutils_managed_tempdir):
    self = request.instance
    tmp_dir = self.mkdtemp()
    self.source = os.path.join(tmp_dir, 'f1')
    self.target = os.path.join(tmp_dir, 'f2')
    self.target_dir = os.path.join(tmp_dir, 'd1')


class TestFileUtil(support.TempdirManager):
    def test_move_file_verbosity(self, caplog):
        f = open(self.source, 'w')
        try:
            f.write('some content')
        finally:
            f.close()

        move_file(self.source, self.target, verbose=0)
        assert not caplog.messages

        # back to original state
        move_file(self.target, self.source, verbose=0)

        move_file(self.source, self.target, verbose=1)
        wanted = ['moving {} -> {}'.format(self.source, self.target)]
        assert caplog.messages == wanted

        # back to original state
        move_file(self.target, self.source, verbose=0)

        caplog.clear()
        # now the target is a dir
        os.mkdir(self.target_dir)
        move_file(self.source, self.target_dir, verbose=1)
        wanted = ['moving {} -> {}'.format(self.source, self.target_dir)]
        assert caplog.messages == wanted

    def test_move_file_exception_unpacking_rename(self):
        # see issue 22182
        with mock.patch("os.rename", side_effect=OSError("wrong", 1)), pytest.raises(
            DistutilsFileError
        ):
            with open(self.source, 'w') as fobj:
                fobj.write('spam eggs')
            move_file(self.source, self.target, verbose=0)

    def test_move_file_exception_unpacking_unlink(self):
        # see issue 22182
        with mock.patch(
            "os.rename", side_effect=OSError(errno.EXDEV, "wrong")
        ), mock.patch("os.unlink", side_effect=OSError("wrong", 1)), pytest.raises(
            DistutilsFileError
        ):
            with open(self.source, 'w') as fobj:
                fobj.write('spam eggs')
            move_file(self.source, self.target, verbose=0)

    def test_copy_file_hard_link(self):
        with open(self.source, 'w') as f:
            f.write('some content')
        # Check first that copy_file() will not fall back on copying the file
        # instead of creating the hard link.
        try:
            os.link(self.source, self.target)
        except OSError as e:
            self.skipTest('os.link: %s' % e)
        else:
            unlink(self.target)
        st = os.stat(self.source)
        copy_file(self.source, self.target, link='hard')
        st2 = os.stat(self.source)
        st3 = os.stat(self.target)
        assert os.path.samestat(st, st2), (st, st2)
        assert os.path.samestat(st2, st3), (st2, st3)
        with open(self.source) as f:
            assert f.read() == 'some content'

    def test_copy_file_hard_link_failure(self):
        # If hard linking fails, copy_file() falls back on copying file
        # (some special filesystems don't support hard linking even under
        #  Unix, see issue #8876).
        with open(self.source, 'w') as f:
            f.write('some content')
        st = os.stat(self.source)
        with mock.patch("os.link", side_effect=OSError(0, "linking unsupported")):
            copy_file(self.source, self.target, link='hard')
        st2 = os.stat(self.source)
        st3 = os.stat(self.target)
        assert os.path.samestat(st, st2), (st, st2)
        assert not os.path.samestat(st2, st3), (st2, st3)
        for fn in (self.source, self.target):
            with open(fn) as f:
                assert f.read() == 'some content'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_filelist.py0000644000175100001730000002474614467657412024461 0ustar00runnerdocker"""Tests for distutils.filelist."""
import os
import re
import logging

from distutils import debug
from distutils.errors import DistutilsTemplateError
from distutils.filelist import glob_to_re, translate_pattern, FileList
from distutils import filelist

import pytest
import jaraco.path

from . import py38compat as os_helper


MANIFEST_IN = """\
include ok
include xo
exclude xo
include foo.tmp
include buildout.cfg
global-include *.x
global-include *.txt
global-exclude *.tmp
recursive-include f *.oo
recursive-exclude global *.x
graft dir
prune dir3
"""


def make_local_path(s):
    """Converts '/' in a string to os.sep"""
    return s.replace('/', os.sep)


class TestFileList:
    def assertNoWarnings(self, caplog):
        warnings = [rec for rec in caplog.records if rec.levelno == logging.WARNING]
        assert not warnings
        caplog.clear()

    def assertWarnings(self, caplog):
        warnings = [rec for rec in caplog.records if rec.levelno == logging.WARNING]
        assert warnings
        caplog.clear()

    def test_glob_to_re(self):
        sep = os.sep
        if os.sep == '\\':
            sep = re.escape(os.sep)

        for glob, regex in (
            # simple cases
            ('foo*', r'(?s:foo[^%(sep)s]*)\Z'),
            ('foo?', r'(?s:foo[^%(sep)s])\Z'),
            ('foo??', r'(?s:foo[^%(sep)s][^%(sep)s])\Z'),
            # special cases
            (r'foo\\*', r'(?s:foo\\\\[^%(sep)s]*)\Z'),
            (r'foo\\\*', r'(?s:foo\\\\\\[^%(sep)s]*)\Z'),
            ('foo????', r'(?s:foo[^%(sep)s][^%(sep)s][^%(sep)s][^%(sep)s])\Z'),
            (r'foo\\??', r'(?s:foo\\\\[^%(sep)s][^%(sep)s])\Z'),
        ):
            regex = regex % {'sep': sep}
            assert glob_to_re(glob) == regex

    def test_process_template_line(self):
        # testing  all MANIFEST.in template patterns
        file_list = FileList()
        mlp = make_local_path

        # simulated file list
        file_list.allfiles = [
            'foo.tmp',
            'ok',
            'xo',
            'four.txt',
            'buildout.cfg',
            # filelist does not filter out VCS directories,
            # it's sdist that does
            mlp('.hg/last-message.txt'),
            mlp('global/one.txt'),
            mlp('global/two.txt'),
            mlp('global/files.x'),
            mlp('global/here.tmp'),
            mlp('f/o/f.oo'),
            mlp('dir/graft-one'),
            mlp('dir/dir2/graft2'),
            mlp('dir3/ok'),
            mlp('dir3/sub/ok.txt'),
        ]

        for line in MANIFEST_IN.split('\n'):
            if line.strip() == '':
                continue
            file_list.process_template_line(line)

        wanted = [
            'ok',
            'buildout.cfg',
            'four.txt',
            mlp('.hg/last-message.txt'),
            mlp('global/one.txt'),
            mlp('global/two.txt'),
            mlp('f/o/f.oo'),
            mlp('dir/graft-one'),
            mlp('dir/dir2/graft2'),
        ]

        assert file_list.files == wanted

    def test_debug_print(self, capsys, monkeypatch):
        file_list = FileList()
        file_list.debug_print('xxx')
        assert capsys.readouterr().out == ''

        monkeypatch.setattr(debug, 'DEBUG', True)
        file_list.debug_print('xxx')
        assert capsys.readouterr().out == 'xxx\n'

    def test_set_allfiles(self):
        file_list = FileList()
        files = ['a', 'b', 'c']
        file_list.set_allfiles(files)
        assert file_list.allfiles == files

    def test_remove_duplicates(self):
        file_list = FileList()
        file_list.files = ['a', 'b', 'a', 'g', 'c', 'g']
        # files must be sorted beforehand (sdist does it)
        file_list.sort()
        file_list.remove_duplicates()
        assert file_list.files == ['a', 'b', 'c', 'g']

    def test_translate_pattern(self):
        # not regex
        assert hasattr(translate_pattern('a', anchor=True, is_regex=False), 'search')

        # is a regex
        regex = re.compile('a')
        assert translate_pattern(regex, anchor=True, is_regex=True) == regex

        # plain string flagged as regex
        assert hasattr(translate_pattern('a', anchor=True, is_regex=True), 'search')

        # glob support
        assert translate_pattern('*.py', anchor=True, is_regex=False).search(
            'filelist.py'
        )

    def test_exclude_pattern(self):
        # return False if no match
        file_list = FileList()
        assert not file_list.exclude_pattern('*.py')

        # return True if files match
        file_list = FileList()
        file_list.files = ['a.py', 'b.py']
        assert file_list.exclude_pattern('*.py')

        # test excludes
        file_list = FileList()
        file_list.files = ['a.py', 'a.txt']
        file_list.exclude_pattern('*.py')
        assert file_list.files == ['a.txt']

    def test_include_pattern(self):
        # return False if no match
        file_list = FileList()
        file_list.set_allfiles([])
        assert not file_list.include_pattern('*.py')

        # return True if files match
        file_list = FileList()
        file_list.set_allfiles(['a.py', 'b.txt'])
        assert file_list.include_pattern('*.py')

        # test * matches all files
        file_list = FileList()
        assert file_list.allfiles is None
        file_list.set_allfiles(['a.py', 'b.txt'])
        file_list.include_pattern('*')
        assert file_list.allfiles == ['a.py', 'b.txt']

    def test_process_template(self, caplog):
        mlp = make_local_path
        # invalid lines
        file_list = FileList()
        for action in (
            'include',
            'exclude',
            'global-include',
            'global-exclude',
            'recursive-include',
            'recursive-exclude',
            'graft',
            'prune',
            'blarg',
        ):
            with pytest.raises(DistutilsTemplateError):
                file_list.process_template_line(action)

        # include
        file_list = FileList()
        file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')])

        file_list.process_template_line('include *.py')
        assert file_list.files == ['a.py']
        self.assertNoWarnings(caplog)

        file_list.process_template_line('include *.rb')
        assert file_list.files == ['a.py']
        self.assertWarnings(caplog)

        # exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', mlp('d/c.py')]

        file_list.process_template_line('exclude *.py')
        assert file_list.files == ['b.txt', mlp('d/c.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('exclude *.rb')
        assert file_list.files == ['b.txt', mlp('d/c.py')]
        self.assertWarnings(caplog)

        # global-include
        file_list = FileList()
        file_list.set_allfiles(['a.py', 'b.txt', mlp('d/c.py')])

        file_list.process_template_line('global-include *.py')
        assert file_list.files == ['a.py', mlp('d/c.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('global-include *.rb')
        assert file_list.files == ['a.py', mlp('d/c.py')]
        self.assertWarnings(caplog)

        # global-exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', mlp('d/c.py')]

        file_list.process_template_line('global-exclude *.py')
        assert file_list.files == ['b.txt']
        self.assertNoWarnings(caplog)

        file_list.process_template_line('global-exclude *.rb')
        assert file_list.files == ['b.txt']
        self.assertWarnings(caplog)

        # recursive-include
        file_list = FileList()
        file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')])

        file_list.process_template_line('recursive-include d *.py')
        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('recursive-include e *.py')
        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
        self.assertWarnings(caplog)

        # recursive-exclude
        file_list = FileList()
        file_list.files = ['a.py', mlp('d/b.py'), mlp('d/c.txt'), mlp('d/d/e.py')]

        file_list.process_template_line('recursive-exclude d *.py')
        assert file_list.files == ['a.py', mlp('d/c.txt')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('recursive-exclude e *.py')
        assert file_list.files == ['a.py', mlp('d/c.txt')]
        self.assertWarnings(caplog)

        # graft
        file_list = FileList()
        file_list.set_allfiles(['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')])

        file_list.process_template_line('graft d')
        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('graft e')
        assert file_list.files == [mlp('d/b.py'), mlp('d/d/e.py')]
        self.assertWarnings(caplog)

        # prune
        file_list = FileList()
        file_list.files = ['a.py', mlp('d/b.py'), mlp('d/d/e.py'), mlp('f/f.py')]

        file_list.process_template_line('prune d')
        assert file_list.files == ['a.py', mlp('f/f.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('prune e')
        assert file_list.files == ['a.py', mlp('f/f.py')]
        self.assertWarnings(caplog)


class TestFindAll:
    @os_helper.skip_unless_symlink
    def test_missing_symlink(self, temp_cwd):
        os.symlink('foo', 'bar')
        assert filelist.findall() == []

    def test_basic_discovery(self, temp_cwd):
        """
        When findall is called with no parameters or with
        '.' as the parameter, the dot should be omitted from
        the results.
        """
        jaraco.path.build({'foo': {'file1.txt': ''}, 'bar': {'file2.txt': ''}})
        file1 = os.path.join('foo', 'file1.txt')
        file2 = os.path.join('bar', 'file2.txt')
        expected = [file2, file1]
        assert sorted(filelist.findall()) == expected

    def test_non_local_discovery(self, tmp_path):
        """
        When findall is called with another path, the full
        path name should be returned.
        """
        filename = tmp_path / 'file1.txt'
        filename.write_text('')
        expected = [str(filename)]
        assert filelist.findall(tmp_path) == expected

    @os_helper.skip_unless_symlink
    def test_symlink_loop(self, tmp_path):
        tmp_path.joinpath('link-to-parent').symlink_to('.')
        tmp_path.joinpath('somefile').write_text('')
        files = filelist.findall(tmp_path)
        assert len(files) == 1
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_install.py0000644000175100001730000002067314467657412024307 0ustar00runnerdocker"""Tests for distutils.command.install."""

import os
import sys
import site
import pathlib
import logging

import pytest

from distutils import sysconfig
from distutils.command.install import install
from distutils.command import install as install_module
from distutils.command.build_ext import build_ext
from distutils.command.install import INSTALL_SCHEMES
from distutils.core import Distribution
from distutils.errors import DistutilsOptionError
from distutils.extension import Extension

from distutils.tests import support
from test import support as test_support


def _make_ext_name(modname):
    return modname + sysconfig.get_config_var('EXT_SUFFIX')


@support.combine_markers
@pytest.mark.usefixtures('save_env')
class TestInstall(
    support.TempdirManager,
):
    @pytest.mark.xfail(
        'platform.system() == "Windows" and sys.version_info > (3, 11)',
        reason="pypa/distutils#148",
    )
    def test_home_installation_scheme(self):
        # This ensure two things:
        # - that --home generates the desired set of directory names
        # - test --home is supported on all platforms
        builddir = self.mkdtemp()
        destination = os.path.join(builddir, "installation")

        dist = Distribution({"name": "foopkg"})
        # script_name need not exist, it just need to be initialized
        dist.script_name = os.path.join(builddir, "setup.py")
        dist.command_obj["build"] = support.DummyCommand(
            build_base=builddir,
            build_lib=os.path.join(builddir, "lib"),
        )

        cmd = install(dist)
        cmd.home = destination
        cmd.ensure_finalized()

        assert cmd.install_base == destination
        assert cmd.install_platbase == destination

        def check_path(got, expected):
            got = os.path.normpath(got)
            expected = os.path.normpath(expected)
            assert got == expected

        impl_name = sys.implementation.name.replace("cpython", "python")
        libdir = os.path.join(destination, "lib", impl_name)
        check_path(cmd.install_lib, libdir)
        _platlibdir = getattr(sys, "platlibdir", "lib")
        platlibdir = os.path.join(destination, _platlibdir, impl_name)
        check_path(cmd.install_platlib, platlibdir)
        check_path(cmd.install_purelib, libdir)
        check_path(
            cmd.install_headers,
            os.path.join(destination, "include", impl_name, "foopkg"),
        )
        check_path(cmd.install_scripts, os.path.join(destination, "bin"))
        check_path(cmd.install_data, destination)

    def test_user_site(self, monkeypatch):
        # test install with --user
        # preparing the environment for the test
        self.tmpdir = self.mkdtemp()
        orig_site = site.USER_SITE
        orig_base = site.USER_BASE
        monkeypatch.setattr(site, 'USER_BASE', os.path.join(self.tmpdir, 'B'))
        monkeypatch.setattr(site, 'USER_SITE', os.path.join(self.tmpdir, 'S'))
        monkeypatch.setattr(install_module, 'USER_BASE', site.USER_BASE)
        monkeypatch.setattr(install_module, 'USER_SITE', site.USER_SITE)

        def _expanduser(path):
            if path.startswith('~'):
                return os.path.normpath(self.tmpdir + path[1:])
            return path

        monkeypatch.setattr(os.path, 'expanduser', _expanduser)

        for key in ('nt_user', 'posix_user'):
            assert key in INSTALL_SCHEMES

        dist = Distribution({'name': 'xx'})
        cmd = install(dist)

        # making sure the user option is there
        options = [name for name, short, label in cmd.user_options]
        assert 'user' in options

        # setting a value
        cmd.user = 1

        # user base and site shouldn't be created yet
        assert not os.path.exists(site.USER_BASE)
        assert not os.path.exists(site.USER_SITE)

        # let's run finalize
        cmd.ensure_finalized()

        # now they should
        assert os.path.exists(site.USER_BASE)
        assert os.path.exists(site.USER_SITE)

        assert 'userbase' in cmd.config_vars
        assert 'usersite' in cmd.config_vars

        actual_headers = os.path.relpath(cmd.install_headers, site.USER_BASE)
        if os.name == 'nt':
            site_path = os.path.relpath(os.path.dirname(orig_site), orig_base)
            include = os.path.join(site_path, 'Include')
        else:
            include = sysconfig.get_python_inc(0, '')
        expect_headers = os.path.join(include, 'xx')

        assert os.path.normcase(actual_headers) == os.path.normcase(expect_headers)

    def test_handle_extra_path(self):
        dist = Distribution({'name': 'xx', 'extra_path': 'path,dirs'})
        cmd = install(dist)

        # two elements
        cmd.handle_extra_path()
        assert cmd.extra_path == ['path', 'dirs']
        assert cmd.extra_dirs == 'dirs'
        assert cmd.path_file == 'path'

        # one element
        cmd.extra_path = ['path']
        cmd.handle_extra_path()
        assert cmd.extra_path == ['path']
        assert cmd.extra_dirs == 'path'
        assert cmd.path_file == 'path'

        # none
        dist.extra_path = cmd.extra_path = None
        cmd.handle_extra_path()
        assert cmd.extra_path is None
        assert cmd.extra_dirs == ''
        assert cmd.path_file is None

        # three elements (no way !)
        cmd.extra_path = 'path,dirs,again'
        with pytest.raises(DistutilsOptionError):
            cmd.handle_extra_path()

    def test_finalize_options(self):
        dist = Distribution({'name': 'xx'})
        cmd = install(dist)

        # must supply either prefix/exec-prefix/home or
        # install-base/install-platbase -- not both
        cmd.prefix = 'prefix'
        cmd.install_base = 'base'
        with pytest.raises(DistutilsOptionError):
            cmd.finalize_options()

        # must supply either home or prefix/exec-prefix -- not both
        cmd.install_base = None
        cmd.home = 'home'
        with pytest.raises(DistutilsOptionError):
            cmd.finalize_options()

        # can't combine user with prefix/exec_prefix/home or
        # install_(plat)base
        cmd.prefix = None
        cmd.user = 'user'
        with pytest.raises(DistutilsOptionError):
            cmd.finalize_options()

    def test_record(self):
        install_dir = self.mkdtemp()
        project_dir, dist = self.create_dist(py_modules=['hello'], scripts=['sayhi'])
        os.chdir(project_dir)
        self.write_file('hello.py', "def main(): print('o hai')")
        self.write_file('sayhi', 'from hello import main; main()')

        cmd = install(dist)
        dist.command_obj['install'] = cmd
        cmd.root = install_dir
        cmd.record = os.path.join(project_dir, 'filelist')
        cmd.ensure_finalized()
        cmd.run()

        f = open(cmd.record)
        try:
            content = f.read()
        finally:
            f.close()

        found = [os.path.basename(line) for line in content.splitlines()]
        expected = [
            'hello.py',
            'hello.%s.pyc' % sys.implementation.cache_tag,
            'sayhi',
            'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2],
        ]
        assert found == expected

    def test_record_extensions(self):
        cmd = test_support.missing_compiler_executable()
        if cmd is not None:
            pytest.skip('The %r command is not found' % cmd)
        install_dir = self.mkdtemp()
        project_dir, dist = self.create_dist(
            ext_modules=[Extension('xx', ['xxmodule.c'])]
        )
        os.chdir(project_dir)
        support.copy_xxmodule_c(project_dir)

        buildextcmd = build_ext(dist)
        support.fixup_build_ext(buildextcmd)
        buildextcmd.ensure_finalized()

        cmd = install(dist)
        dist.command_obj['install'] = cmd
        dist.command_obj['build_ext'] = buildextcmd
        cmd.root = install_dir
        cmd.record = os.path.join(project_dir, 'filelist')
        cmd.ensure_finalized()
        cmd.run()

        content = pathlib.Path(cmd.record).read_text()

        found = [os.path.basename(line) for line in content.splitlines()]
        expected = [
            _make_ext_name('xx'),
            'UNKNOWN-0.0.0-py%s.%s.egg-info' % sys.version_info[:2],
        ]
        assert found == expected

    def test_debug_mode(self, caplog, monkeypatch):
        # this covers the code called when DEBUG is set
        monkeypatch.setattr(install_module, 'DEBUG', True)
        caplog.set_level(logging.DEBUG)
        self.test_record()
        assert any(rec for rec in caplog.records if rec.levelno == logging.DEBUG)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_install_data.py0000644000175100001730000000406614467657412025276 0ustar00runnerdocker"""Tests for distutils.command.install_data."""
import os

import pytest

from distutils.command.install_data import install_data
from distutils.tests import support


@pytest.mark.usefixtures('save_env')
class TestInstallData(
    support.TempdirManager,
):
    def test_simple_run(self):
        pkg_dir, dist = self.create_dist()
        cmd = install_data(dist)
        cmd.install_dir = inst = os.path.join(pkg_dir, 'inst')

        # data_files can contain
        #  - simple files
        #  - a tuple with a path, and a list of file
        one = os.path.join(pkg_dir, 'one')
        self.write_file(one, 'xxx')
        inst2 = os.path.join(pkg_dir, 'inst2')
        two = os.path.join(pkg_dir, 'two')
        self.write_file(two, 'xxx')

        cmd.data_files = [one, (inst2, [two])]
        assert cmd.get_inputs() == [one, (inst2, [two])]

        # let's run the command
        cmd.ensure_finalized()
        cmd.run()

        # let's check the result
        assert len(cmd.get_outputs()) == 2
        rtwo = os.path.split(two)[-1]
        assert os.path.exists(os.path.join(inst2, rtwo))
        rone = os.path.split(one)[-1]
        assert os.path.exists(os.path.join(inst, rone))
        cmd.outfiles = []

        # let's try with warn_dir one
        cmd.warn_dir = 1
        cmd.ensure_finalized()
        cmd.run()

        # let's check the result
        assert len(cmd.get_outputs()) == 2
        assert os.path.exists(os.path.join(inst2, rtwo))
        assert os.path.exists(os.path.join(inst, rone))
        cmd.outfiles = []

        # now using root and empty dir
        cmd.root = os.path.join(pkg_dir, 'root')
        inst4 = os.path.join(pkg_dir, 'inst4')
        three = os.path.join(cmd.install_dir, 'three')
        self.write_file(three, 'xx')
        cmd.data_files = [one, (inst2, [two]), ('inst3', [three]), (inst4, [])]
        cmd.ensure_finalized()
        cmd.run()

        # let's check the result
        assert len(cmd.get_outputs()) == 4
        assert os.path.exists(os.path.join(inst2, rtwo))
        assert os.path.exists(os.path.join(inst, rone))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_install_headers.py0000644000175100001730000000165014467657412025774 0ustar00runnerdocker"""Tests for distutils.command.install_headers."""
import os

import pytest

from distutils.command.install_headers import install_headers
from distutils.tests import support


@pytest.mark.usefixtures('save_env')
class TestInstallHeaders(
    support.TempdirManager,
):
    def test_simple_run(self):
        # we have two headers
        header_list = self.mkdtemp()
        header1 = os.path.join(header_list, 'header1')
        header2 = os.path.join(header_list, 'header2')
        self.write_file(header1)
        self.write_file(header2)
        headers = [header1, header2]

        pkg_dir, dist = self.create_dist(headers=headers)
        cmd = install_headers(dist)
        assert cmd.get_inputs() == headers

        # let's run the command
        cmd.install_dir = os.path.join(pkg_dir, 'inst')
        cmd.ensure_finalized()
        cmd.run()

        # let's check the results
        assert len(cmd.get_outputs()) == 2
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_install_lib.py0000644000175100001730000000703114467657412025126 0ustar00runnerdocker"""Tests for distutils.command.install_data."""
import sys
import os
import importlib.util

import pytest

from distutils.command.install_lib import install_lib
from distutils.extension import Extension
from distutils.tests import support
from distutils.errors import DistutilsOptionError


@support.combine_markers
@pytest.mark.usefixtures('save_env')
class TestInstallLib(
    support.TempdirManager,
):
    def test_finalize_options(self):
        dist = self.create_dist()[1]
        cmd = install_lib(dist)

        cmd.finalize_options()
        assert cmd.compile == 1
        assert cmd.optimize == 0

        # optimize must be 0, 1, or 2
        cmd.optimize = 'foo'
        with pytest.raises(DistutilsOptionError):
            cmd.finalize_options()
        cmd.optimize = '4'
        with pytest.raises(DistutilsOptionError):
            cmd.finalize_options()

        cmd.optimize = '2'
        cmd.finalize_options()
        assert cmd.optimize == 2

    @pytest.mark.skipif('sys.dont_write_bytecode')
    def test_byte_compile(self):
        project_dir, dist = self.create_dist()
        os.chdir(project_dir)
        cmd = install_lib(dist)
        cmd.compile = cmd.optimize = 1

        f = os.path.join(project_dir, 'foo.py')
        self.write_file(f, '# python file')
        cmd.byte_compile([f])
        pyc_file = importlib.util.cache_from_source('foo.py', optimization='')
        pyc_opt_file = importlib.util.cache_from_source(
            'foo.py', optimization=cmd.optimize
        )
        assert os.path.exists(pyc_file)
        assert os.path.exists(pyc_opt_file)

    def test_get_outputs(self):
        project_dir, dist = self.create_dist()
        os.chdir(project_dir)
        os.mkdir('spam')
        cmd = install_lib(dist)

        # setting up a dist environment
        cmd.compile = cmd.optimize = 1
        cmd.install_dir = self.mkdtemp()
        f = os.path.join(project_dir, 'spam', '__init__.py')
        self.write_file(f, '# python package')
        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
        cmd.distribution.packages = ['spam']
        cmd.distribution.script_name = 'setup.py'

        # get_outputs should return 4 elements: spam/__init__.py and .pyc,
        # foo.import-tag-abiflags.so / foo.pyd
        outputs = cmd.get_outputs()
        assert len(outputs) == 4, outputs

    def test_get_inputs(self):
        project_dir, dist = self.create_dist()
        os.chdir(project_dir)
        os.mkdir('spam')
        cmd = install_lib(dist)

        # setting up a dist environment
        cmd.compile = cmd.optimize = 1
        cmd.install_dir = self.mkdtemp()
        f = os.path.join(project_dir, 'spam', '__init__.py')
        self.write_file(f, '# python package')
        cmd.distribution.ext_modules = [Extension('foo', ['xxx'])]
        cmd.distribution.packages = ['spam']
        cmd.distribution.script_name = 'setup.py'

        # get_inputs should return 2 elements: spam/__init__.py and
        # foo.import-tag-abiflags.so / foo.pyd
        inputs = cmd.get_inputs()
        assert len(inputs) == 2, inputs

    def test_dont_write_bytecode(self, caplog):
        # makes sure byte_compile is not used
        dist = self.create_dist()[1]
        cmd = install_lib(dist)
        cmd.compile = 1
        cmd.optimize = 1

        old_dont_write_bytecode = sys.dont_write_bytecode
        sys.dont_write_bytecode = True
        try:
            cmd.byte_compile([])
        finally:
            sys.dont_write_bytecode = old_dont_write_bytecode

        assert 'byte-compiling is disabled' in caplog.messages[0]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_install_scripts.py0000644000175100001730000000421214467657412026045 0ustar00runnerdocker"""Tests for distutils.command.install_scripts."""

import os

from distutils.command.install_scripts import install_scripts
from distutils.core import Distribution

from distutils.tests import support


class TestInstallScripts(support.TempdirManager):
    def test_default_settings(self):
        dist = Distribution()
        dist.command_obj["build"] = support.DummyCommand(build_scripts="/foo/bar")
        dist.command_obj["install"] = support.DummyCommand(
            install_scripts="/splat/funk",
            force=1,
            skip_build=1,
        )
        cmd = install_scripts(dist)
        assert not cmd.force
        assert not cmd.skip_build
        assert cmd.build_dir is None
        assert cmd.install_dir is None

        cmd.finalize_options()

        assert cmd.force
        assert cmd.skip_build
        assert cmd.build_dir == "/foo/bar"
        assert cmd.install_dir == "/splat/funk"

    def test_installation(self):
        source = self.mkdtemp()
        expected = []

        def write_script(name, text):
            expected.append(name)
            f = open(os.path.join(source, name), "w")
            try:
                f.write(text)
            finally:
                f.close()

        write_script(
            "script1.py",
            (
                "#! /usr/bin/env python2.3\n"
                "# bogus script w/ Python sh-bang\n"
                "pass\n"
            ),
        )
        write_script(
            "script2.py",
            ("#!/usr/bin/python\n" "# bogus script w/ Python sh-bang\n" "pass\n"),
        )
        write_script(
            "shell.sh", ("#!/bin/sh\n" "# bogus shell script w/ sh-bang\n" "exit 0\n")
        )

        target = self.mkdtemp()
        dist = Distribution()
        dist.command_obj["build"] = support.DummyCommand(build_scripts=source)
        dist.command_obj["install"] = support.DummyCommand(
            install_scripts=target,
            force=1,
            skip_build=1,
        )
        cmd = install_scripts(dist)
        cmd.finalize_options()
        cmd.run()

        installed = os.listdir(target)
        for name in expected:
            assert name in installed
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_log.py0000644000175100001730000000050414467657412023411 0ustar00runnerdocker"""Tests for distutils.log"""

import logging

from distutils._log import log


class TestLog:
    def test_non_ascii(self, caplog):
        caplog.set_level(logging.DEBUG)
        log.debug('Dεbug\tMėssãge')
        log.fatal('Fαtal\tÈrrōr')
        assert caplog.messages == ['Dεbug\tMėssãge', 'Fαtal\tÈrrōr']
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_msvc9compiler.py0000644000175100001730000001324114467657412025426 0ustar00runnerdocker"""Tests for distutils.msvc9compiler."""
import sys
import os

from distutils.errors import DistutilsPlatformError
from distutils.tests import support
import pytest

# A manifest with the only assembly reference being the msvcrt assembly, so
# should have the assembly completely stripped.  Note that although the
# assembly has a  reference the assembly is removed - that is
# currently a "feature", not a bug :)
_MANIFEST_WITH_ONLY_MSVC_REFERENCE = """\


  
    
      
        
        
      
    
  
  
    
      
      
    
  

"""

# A manifest with references to assemblies other than msvcrt.  When processed,
# this assembly should be returned with just the msvcrt part removed.
_MANIFEST_WITH_MULTIPLE_REFERENCES = """\


  
    
      
        
        
      
    
  
  
    
      
      
    
  
  
    
      
    
  

"""

_CLEANED_MANIFEST = """\


  
    
      
        
        
      
    
  
  

  
  
    
      
    
  
"""

if sys.platform == "win32":
    from distutils.msvccompiler import get_build_version

    if get_build_version() >= 8.0:
        SKIP_MESSAGE = None
    else:
        SKIP_MESSAGE = "These tests are only for MSVC8.0 or above"
else:
    SKIP_MESSAGE = "These tests are only for win32"


@pytest.mark.skipif('SKIP_MESSAGE', reason=SKIP_MESSAGE)
class Testmsvc9compiler(support.TempdirManager):
    def test_no_compiler(self):
        # makes sure query_vcvarsall raises
        # a DistutilsPlatformError if the compiler
        # is not found
        from distutils.msvc9compiler import query_vcvarsall

        def _find_vcvarsall(version):
            return None

        from distutils import msvc9compiler

        old_find_vcvarsall = msvc9compiler.find_vcvarsall
        msvc9compiler.find_vcvarsall = _find_vcvarsall
        try:
            with pytest.raises(DistutilsPlatformError):
                query_vcvarsall('wont find this version')
        finally:
            msvc9compiler.find_vcvarsall = old_find_vcvarsall

    def test_reg_class(self):
        from distutils.msvc9compiler import Reg

        with pytest.raises(KeyError):
            Reg.get_value('xxx', 'xxx')

        # looking for values that should exist on all
        # windows registry versions.
        path = r'Control Panel\Desktop'
        v = Reg.get_value(path, 'dragfullwindows')
        assert v in ('0', '1', '2')

        import winreg

        HKCU = winreg.HKEY_CURRENT_USER
        keys = Reg.read_keys(HKCU, 'xxxx')
        assert keys is None

        keys = Reg.read_keys(HKCU, r'Control Panel')
        assert 'Desktop' in keys

    def test_remove_visual_c_ref(self):
        from distutils.msvc9compiler import MSVCCompiler

        tempdir = self.mkdtemp()
        manifest = os.path.join(tempdir, 'manifest')
        f = open(manifest, 'w')
        try:
            f.write(_MANIFEST_WITH_MULTIPLE_REFERENCES)
        finally:
            f.close()

        compiler = MSVCCompiler()
        compiler._remove_visual_c_ref(manifest)

        # see what we got
        f = open(manifest)
        try:
            # removing trailing spaces
            content = '\n'.join([line.rstrip() for line in f.readlines()])
        finally:
            f.close()

        # makes sure the manifest was properly cleaned
        assert content == _CLEANED_MANIFEST

    def test_remove_entire_manifest(self):
        from distutils.msvc9compiler import MSVCCompiler

        tempdir = self.mkdtemp()
        manifest = os.path.join(tempdir, 'manifest')
        f = open(manifest, 'w')
        try:
            f.write(_MANIFEST_WITH_ONLY_MSVC_REFERENCE)
        finally:
            f.close()

        compiler = MSVCCompiler()
        got = compiler._remove_visual_c_ref(manifest)
        assert got is None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_msvccompiler.py0000644000175100001730000000676214467657412025347 0ustar00runnerdocker"""Tests for distutils._msvccompiler."""
import sys
import os
import threading
import unittest.mock as mock

import pytest

from distutils.errors import DistutilsPlatformError
from distutils.tests import support
from distutils import _msvccompiler


needs_winreg = pytest.mark.skipif('not hasattr(_msvccompiler, "winreg")')


class Testmsvccompiler(support.TempdirManager):
    def test_no_compiler(self):
        # makes sure query_vcvarsall raises
        # a DistutilsPlatformError if the compiler
        # is not found
        def _find_vcvarsall(plat_spec):
            return None, None

        old_find_vcvarsall = _msvccompiler._find_vcvarsall
        _msvccompiler._find_vcvarsall = _find_vcvarsall
        try:
            with pytest.raises(DistutilsPlatformError):
                _msvccompiler._get_vc_env(
                    'wont find this version',
                )
        finally:
            _msvccompiler._find_vcvarsall = old_find_vcvarsall

    @needs_winreg
    def test_get_vc_env_unicode(self):
        test_var = 'ṰḖṤṪ┅ṼẨṜ'
        test_value = '₃⁴₅'

        # Ensure we don't early exit from _get_vc_env
        old_distutils_use_sdk = os.environ.pop('DISTUTILS_USE_SDK', None)
        os.environ[test_var] = test_value
        try:
            env = _msvccompiler._get_vc_env('x86')
            assert test_var.lower() in env
            assert test_value == env[test_var.lower()]
        finally:
            os.environ.pop(test_var)
            if old_distutils_use_sdk:
                os.environ['DISTUTILS_USE_SDK'] = old_distutils_use_sdk

    @needs_winreg
    @pytest.mark.parametrize('ver', (2015, 2017))
    def test_get_vc(self, ver):
        # This function cannot be mocked, so pass if VC is found
        # and skip otherwise.
        lookup = getattr(_msvccompiler, f'_find_vc{ver}')
        expected_version = {2015: 14, 2017: 15}[ver]
        version, path = lookup()
        if not version:
            pytest.skip(f"VS {ver} is not installed")
        assert version >= expected_version
        assert os.path.isdir(path)


class CheckThread(threading.Thread):
    exc_info = None

    def run(self):
        try:
            super().run()
        except Exception:
            self.exc_info = sys.exc_info()

    def __bool__(self):
        return not self.exc_info


class TestSpawn:
    def test_concurrent_safe(self):
        """
        Concurrent calls to spawn should have consistent results.
        """
        compiler = _msvccompiler.MSVCCompiler()
        compiler._paths = "expected"
        inner_cmd = 'import os; assert os.environ["PATH"] == "expected"'
        command = [sys.executable, '-c', inner_cmd]

        threads = [
            CheckThread(target=compiler.spawn, args=[command]) for n in range(100)
        ]
        for thread in threads:
            thread.start()
        for thread in threads:
            thread.join()
        assert all(threads)

    def test_concurrent_safe_fallback(self):
        """
        If CCompiler.spawn has been monkey-patched without support
        for an env, it should still execute.
        """
        from distutils import ccompiler

        compiler = _msvccompiler.MSVCCompiler()
        compiler._paths = "expected"

        def CCompiler_spawn(self, cmd):
            "A spawn without an env argument."
            assert os.environ["PATH"] == "expected"

        with mock.patch.object(ccompiler.CCompiler, 'spawn', CCompiler_spawn):
            compiler.spawn(["n/a"])

        assert os.environ.get("PATH") != "expected"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_register.py0000644000175100001730000002137614467657412024466 0ustar00runnerdocker"""Tests for distutils.command.register."""
import os
import getpass
import urllib

from distutils.command import register as register_module
from distutils.command.register import register
from distutils.errors import DistutilsSetupError

from distutils.tests.test_config import BasePyPIRCCommandTestCase
import pytest

try:
    import docutils
except ImportError:
    docutils = None

PYPIRC_NOPASSWORD = """\
[distutils]

index-servers =
    server1

[server1]
username:me
"""

WANTED_PYPIRC = """\
[distutils]
index-servers =
    pypi

[pypi]
username:tarek
password:password
"""


class Inputs:
    """Fakes user inputs."""

    def __init__(self, *answers):
        self.answers = answers
        self.index = 0

    def __call__(self, prompt=''):
        try:
            return self.answers[self.index]
        finally:
            self.index += 1


class FakeOpener:
    """Fakes a PyPI server"""

    def __init__(self):
        self.reqs = []

    def __call__(self, *args):
        return self

    def open(self, req, data=None, timeout=None):
        self.reqs.append(req)
        return self

    def read(self):
        return b'xxx'

    def getheader(self, name, default=None):
        return {
            'content-type': 'text/plain; charset=utf-8',
        }.get(name.lower(), default)


@pytest.fixture(autouse=True)
def autopass(monkeypatch):
    monkeypatch.setattr(getpass, 'getpass', lambda prompt: 'password')


@pytest.fixture(autouse=True)
def fake_opener(monkeypatch, request):
    opener = FakeOpener()
    monkeypatch.setattr(urllib.request, 'build_opener', opener)
    monkeypatch.setattr(urllib.request, '_opener', None)
    request.instance.conn = opener


class TestRegister(BasePyPIRCCommandTestCase):
    def _get_cmd(self, metadata=None):
        if metadata is None:
            metadata = {
                'url': 'xxx',
                'author': 'xxx',
                'author_email': 'xxx',
                'name': 'xxx',
                'version': 'xxx',
                'long_description': 'xxx',
            }
        pkg_info, dist = self.create_dist(**metadata)
        return register(dist)

    def test_create_pypirc(self):
        # this test makes sure a .pypirc file
        # is created when requested.

        # let's create a register instance
        cmd = self._get_cmd()

        # we shouldn't have a .pypirc file yet
        assert not os.path.exists(self.rc)

        # patching input and getpass.getpass
        # so register gets happy
        #
        # Here's what we are faking :
        # use your existing login (choice 1.)
        # Username : 'tarek'
        # Password : 'password'
        # Save your login (y/N)? : 'y'
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

        # we should have a brand new .pypirc file
        assert os.path.exists(self.rc)

        # with the content similar to WANTED_PYPIRC
        f = open(self.rc)
        try:
            content = f.read()
            assert content == WANTED_PYPIRC
        finally:
            f.close()

        # now let's make sure the .pypirc file generated
        # really works : we shouldn't be asked anything
        # if we run the command again
        def _no_way(prompt=''):
            raise AssertionError(prompt)

        register_module.input = _no_way

        cmd.show_response = 1
        cmd.run()

        # let's see what the server received : we should
        # have 2 similar requests
        assert len(self.conn.reqs) == 2
        req1 = dict(self.conn.reqs[0].headers)
        req2 = dict(self.conn.reqs[1].headers)

        assert req1['Content-length'] == '1358'
        assert req2['Content-length'] == '1358'
        assert b'xxx' in self.conn.reqs[1].data

    def test_password_not_in_file(self):
        self.write_file(self.rc, PYPIRC_NOPASSWORD)
        cmd = self._get_cmd()
        cmd._set_config()
        cmd.finalize_options()
        cmd.send_metadata()

        # dist.password should be set
        # therefore used afterwards by other commands
        assert cmd.distribution.password == 'password'

    def test_registering(self):
        # this test runs choice 2
        cmd = self._get_cmd()
        inputs = Inputs('2', 'tarek', 'tarek@ziade.org')
        register_module.input = inputs.__call__
        try:
            # let's run the command
            cmd.run()
        finally:
            del register_module.input

        # we should have send a request
        assert len(self.conn.reqs) == 1
        req = self.conn.reqs[0]
        headers = dict(req.headers)
        assert headers['Content-length'] == '608'
        assert b'tarek' in req.data

    def test_password_reset(self):
        # this test runs choice 3
        cmd = self._get_cmd()
        inputs = Inputs('3', 'tarek@ziade.org')
        register_module.input = inputs.__call__
        try:
            # let's run the command
            cmd.run()
        finally:
            del register_module.input

        # we should have send a request
        assert len(self.conn.reqs) == 1
        req = self.conn.reqs[0]
        headers = dict(req.headers)
        assert headers['Content-length'] == '290'
        assert b'tarek' in req.data

    def test_strict(self):
        # testing the strict option
        # when on, the register command stops if
        # the metadata is incomplete or if
        # long_description is not reSt compliant

        pytest.importorskip('docutils')

        # empty metadata
        cmd = self._get_cmd({})
        cmd.ensure_finalized()
        cmd.strict = 1
        with pytest.raises(DistutilsSetupError):
            cmd.run()

        # metadata are OK but long_description is broken
        metadata = {
            'url': 'xxx',
            'author': 'xxx',
            'author_email': 'éxéxé',
            'name': 'xxx',
            'version': 'xxx',
            'long_description': 'title\n==\n\ntext',
        }

        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = 1
        with pytest.raises(DistutilsSetupError):
            cmd.run()

        # now something that works
        metadata['long_description'] = 'title\n=====\n\ntext'
        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = 1
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

        # strict is not by default
        cmd = self._get_cmd()
        cmd.ensure_finalized()
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

        # and finally a Unicode test (bug #12114)
        metadata = {
            'url': 'xxx',
            'author': '\u00c9ric',
            'author_email': 'xxx',
            'name': 'xxx',
            'version': 'xxx',
            'description': 'Something about esszet \u00df',
            'long_description': 'More things about esszet \u00df',
        }

        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = 1
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        # let's run the command
        try:
            cmd.run()
        finally:
            del register_module.input

    def test_register_invalid_long_description(self, monkeypatch):
        pytest.importorskip('docutils')
        description = ':funkie:`str`'  # mimic Sphinx-specific markup
        metadata = {
            'url': 'xxx',
            'author': 'xxx',
            'author_email': 'xxx',
            'name': 'xxx',
            'version': 'xxx',
            'long_description': description,
        }
        cmd = self._get_cmd(metadata)
        cmd.ensure_finalized()
        cmd.strict = True
        inputs = Inputs('2', 'tarek', 'tarek@ziade.org')
        monkeypatch.setattr(register_module, 'input', inputs, raising=False)

        with pytest.raises(DistutilsSetupError):
            cmd.run()

    def test_list_classifiers(self, caplog):
        cmd = self._get_cmd()
        cmd.list_classifiers = 1
        cmd.run()
        assert caplog.messages == ['running check', 'xxx']

    def test_show_response(self, caplog):
        # test that the --show-response option return a well formatted response
        cmd = self._get_cmd()
        inputs = Inputs('1', 'tarek', 'y')
        register_module.input = inputs.__call__
        cmd.show_response = 1
        try:
            cmd.run()
        finally:
            del register_module.input

        assert caplog.messages[3] == 75 * '-' + '\nxxx\n' + 75 * '-'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_sdist.py0000644000175100001730000003673414467657412023774 0ustar00runnerdocker"""Tests for distutils.command.sdist."""
import os
import tarfile
import warnings
import zipfile
from os.path import join
from textwrap import dedent
from .unix_compat import require_unix_id, require_uid_0, pwd, grp

import pytest
import path
import jaraco.path

from .py38compat import check_warnings

from distutils.command.sdist import sdist, show_formats
from distutils.core import Distribution
from distutils.tests.test_config import BasePyPIRCCommandTestCase
from distutils.errors import DistutilsOptionError
from distutils.spawn import find_executable  # noqa: F401
from distutils.filelist import FileList
from distutils.archive_util import ARCHIVE_FORMATS

SETUP_PY = """
from distutils.core import setup
import somecode

setup(name='fake')
"""

MANIFEST = """\
# file GENERATED by distutils, do NOT edit
README
buildout.cfg
inroot.txt
setup.py
data%(sep)sdata.dt
scripts%(sep)sscript.py
some%(sep)sfile.txt
some%(sep)sother_file.txt
somecode%(sep)s__init__.py
somecode%(sep)sdoc.dat
somecode%(sep)sdoc.txt
"""


@pytest.fixture(autouse=True)
def project_dir(request, pypirc):
    self = request.instance
    jaraco.path.build(
        {
            'somecode': {
                '__init__.py': '#',
            },
            'README': 'xxx',
            'setup.py': SETUP_PY,
        },
        self.tmp_dir,
    )
    with path.Path(self.tmp_dir):
        yield


class TestSDist(BasePyPIRCCommandTestCase):
    def get_cmd(self, metadata=None):
        """Returns a cmd"""
        if metadata is None:
            metadata = {
                'name': 'fake',
                'version': '1.0',
                'url': 'xxx',
                'author': 'xxx',
                'author_email': 'xxx',
            }
        dist = Distribution(metadata)
        dist.script_name = 'setup.py'
        dist.packages = ['somecode']
        dist.include_package_data = True
        cmd = sdist(dist)
        cmd.dist_dir = 'dist'
        return dist, cmd

    @pytest.mark.usefixtures('needs_zlib')
    def test_prune_file_list(self):
        # this test creates a project with some VCS dirs and an NFS rename
        # file, then launches sdist to check they get pruned on all systems

        # creating VCS directories with some files in them
        os.mkdir(join(self.tmp_dir, 'somecode', '.svn'))
        self.write_file((self.tmp_dir, 'somecode', '.svn', 'ok.py'), 'xxx')

        os.mkdir(join(self.tmp_dir, 'somecode', '.hg'))
        self.write_file((self.tmp_dir, 'somecode', '.hg', 'ok'), 'xxx')

        os.mkdir(join(self.tmp_dir, 'somecode', '.git'))
        self.write_file((self.tmp_dir, 'somecode', '.git', 'ok'), 'xxx')

        self.write_file((self.tmp_dir, 'somecode', '.nfs0001'), 'xxx')

        # now building a sdist
        dist, cmd = self.get_cmd()

        # zip is available universally
        # (tar might not be installed under win32)
        cmd.formats = ['zip']

        cmd.ensure_finalized()
        cmd.run()

        # now let's check what we have
        dist_folder = join(self.tmp_dir, 'dist')
        files = os.listdir(dist_folder)
        assert files == ['fake-1.0.zip']

        zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
        try:
            content = zip_file.namelist()
        finally:
            zip_file.close()

        # making sure everything has been pruned correctly
        expected = [
            '',
            'PKG-INFO',
            'README',
            'setup.py',
            'somecode/',
            'somecode/__init__.py',
        ]
        assert sorted(content) == ['fake-1.0/' + x for x in expected]

    @pytest.mark.usefixtures('needs_zlib')
    @pytest.mark.skipif("not find_executable('tar')")
    @pytest.mark.skipif("not find_executable('gzip')")
    def test_make_distribution(self):
        # now building a sdist
        dist, cmd = self.get_cmd()

        # creating a gztar then a tar
        cmd.formats = ['gztar', 'tar']
        cmd.ensure_finalized()
        cmd.run()

        # making sure we have two files
        dist_folder = join(self.tmp_dir, 'dist')
        result = os.listdir(dist_folder)
        result.sort()
        assert result == ['fake-1.0.tar', 'fake-1.0.tar.gz']

        os.remove(join(dist_folder, 'fake-1.0.tar'))
        os.remove(join(dist_folder, 'fake-1.0.tar.gz'))

        # now trying a tar then a gztar
        cmd.formats = ['tar', 'gztar']

        cmd.ensure_finalized()
        cmd.run()

        result = os.listdir(dist_folder)
        result.sort()
        assert result == ['fake-1.0.tar', 'fake-1.0.tar.gz']

    @pytest.mark.usefixtures('needs_zlib')
    def test_add_defaults(self):
        # http://bugs.python.org/issue2279

        # add_default should also include
        # data_files and package_data
        dist, cmd = self.get_cmd()

        # filling data_files by pointing files
        # in package_data
        dist.package_data = {'': ['*.cfg', '*.dat'], 'somecode': ['*.txt']}
        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
        self.write_file((self.tmp_dir, 'somecode', 'doc.dat'), '#')

        # adding some data in data_files
        data_dir = join(self.tmp_dir, 'data')
        os.mkdir(data_dir)
        self.write_file((data_dir, 'data.dt'), '#')
        some_dir = join(self.tmp_dir, 'some')
        os.mkdir(some_dir)
        # make sure VCS directories are pruned (#14004)
        hg_dir = join(self.tmp_dir, '.hg')
        os.mkdir(hg_dir)
        self.write_file((hg_dir, 'last-message.txt'), '#')
        # a buggy regex used to prevent this from working on windows (#6884)
        self.write_file((self.tmp_dir, 'buildout.cfg'), '#')
        self.write_file((self.tmp_dir, 'inroot.txt'), '#')
        self.write_file((some_dir, 'file.txt'), '#')
        self.write_file((some_dir, 'other_file.txt'), '#')

        dist.data_files = [
            ('data', ['data/data.dt', 'buildout.cfg', 'inroot.txt', 'notexisting']),
            'some/file.txt',
            'some/other_file.txt',
        ]

        # adding a script
        script_dir = join(self.tmp_dir, 'scripts')
        os.mkdir(script_dir)
        self.write_file((script_dir, 'script.py'), '#')
        dist.scripts = [join('scripts', 'script.py')]

        cmd.formats = ['zip']
        cmd.use_defaults = True

        cmd.ensure_finalized()
        cmd.run()

        # now let's check what we have
        dist_folder = join(self.tmp_dir, 'dist')
        files = os.listdir(dist_folder)
        assert files == ['fake-1.0.zip']

        zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip'))
        try:
            content = zip_file.namelist()
        finally:
            zip_file.close()

        # making sure everything was added
        expected = [
            '',
            'PKG-INFO',
            'README',
            'buildout.cfg',
            'data/',
            'data/data.dt',
            'inroot.txt',
            'scripts/',
            'scripts/script.py',
            'setup.py',
            'some/',
            'some/file.txt',
            'some/other_file.txt',
            'somecode/',
            'somecode/__init__.py',
            'somecode/doc.dat',
            'somecode/doc.txt',
        ]
        assert sorted(content) == ['fake-1.0/' + x for x in expected]

        # checking the MANIFEST
        f = open(join(self.tmp_dir, 'MANIFEST'))
        try:
            manifest = f.read()
        finally:
            f.close()
        assert manifest == MANIFEST % {'sep': os.sep}

    @staticmethod
    def warnings(messages, prefix='warning: '):
        return [msg for msg in messages if msg.startswith(prefix)]

    @pytest.mark.usefixtures('needs_zlib')
    def test_metadata_check_option(self, caplog):
        # testing the `medata-check` option
        dist, cmd = self.get_cmd(metadata={})

        # this should raise some warnings !
        # with the `check` subcommand
        cmd.ensure_finalized()
        cmd.run()
        assert len(self.warnings(caplog.messages, 'warning: check: ')) == 1

        # trying with a complete set of metadata
        caplog.clear()
        dist, cmd = self.get_cmd()
        cmd.ensure_finalized()
        cmd.metadata_check = 0
        cmd.run()
        assert len(self.warnings(caplog.messages, 'warning: check: ')) == 0

    def test_check_metadata_deprecated(self):
        # makes sure make_metadata is deprecated
        dist, cmd = self.get_cmd()
        with check_warnings() as w:
            warnings.simplefilter("always")
            cmd.check_metadata()
            assert len(w.warnings) == 1

    def test_show_formats(self, capsys):
        show_formats()

        # the output should be a header line + one line per format
        num_formats = len(ARCHIVE_FORMATS.keys())
        output = [
            line
            for line in capsys.readouterr().out.split('\n')
            if line.strip().startswith('--formats=')
        ]
        assert len(output) == num_formats

    def test_finalize_options(self):
        dist, cmd = self.get_cmd()
        cmd.finalize_options()

        # default options set by finalize
        assert cmd.manifest == 'MANIFEST'
        assert cmd.template == 'MANIFEST.in'
        assert cmd.dist_dir == 'dist'

        # formats has to be a string splitable on (' ', ',') or
        # a stringlist
        cmd.formats = 1
        with pytest.raises(DistutilsOptionError):
            cmd.finalize_options()
        cmd.formats = ['zip']
        cmd.finalize_options()

        # formats has to be known
        cmd.formats = 'supazipa'
        with pytest.raises(DistutilsOptionError):
            cmd.finalize_options()

    # the following tests make sure there is a nice error message instead
    # of a traceback when parsing an invalid manifest template

    def _check_template(self, content, caplog):
        dist, cmd = self.get_cmd()
        os.chdir(self.tmp_dir)
        self.write_file('MANIFEST.in', content)
        cmd.ensure_finalized()
        cmd.filelist = FileList()
        cmd.read_template()
        assert len(self.warnings(caplog.messages)) == 1

    def test_invalid_template_unknown_command(self, caplog):
        self._check_template('taunt knights *', caplog)

    def test_invalid_template_wrong_arguments(self, caplog):
        # this manifest command takes one argument
        self._check_template('prune', caplog)

    @pytest.mark.skipif("platform.system() != 'Windows'")
    def test_invalid_template_wrong_path(self, caplog):
        # on Windows, trailing slashes are not allowed
        # this used to crash instead of raising a warning: #8286
        self._check_template('include examples/', caplog)

    @pytest.mark.usefixtures('needs_zlib')
    def test_get_file_list(self):
        # make sure MANIFEST is recalculated
        dist, cmd = self.get_cmd()

        # filling data_files by pointing files in package_data
        dist.package_data = {'somecode': ['*.txt']}
        self.write_file((self.tmp_dir, 'somecode', 'doc.txt'), '#')
        cmd.formats = ['gztar']
        cmd.ensure_finalized()
        cmd.run()

        f = open(cmd.manifest)
        try:
            manifest = [
                line.strip() for line in f.read().split('\n') if line.strip() != ''
            ]
        finally:
            f.close()

        assert len(manifest) == 5

        # adding a file
        self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#')

        # make sure build_py is reinitialized, like a fresh run
        build_py = dist.get_command_obj('build_py')
        build_py.finalized = False
        build_py.ensure_finalized()

        cmd.run()

        f = open(cmd.manifest)
        try:
            manifest2 = [
                line.strip() for line in f.read().split('\n') if line.strip() != ''
            ]
        finally:
            f.close()

        # do we have the new file in MANIFEST ?
        assert len(manifest2) == 6
        assert 'doc2.txt' in manifest2[-1]

    @pytest.mark.usefixtures('needs_zlib')
    def test_manifest_marker(self):
        # check that autogenerated MANIFESTs have a marker
        dist, cmd = self.get_cmd()
        cmd.ensure_finalized()
        cmd.run()

        f = open(cmd.manifest)
        try:
            manifest = [
                line.strip() for line in f.read().split('\n') if line.strip() != ''
            ]
        finally:
            f.close()

        assert manifest[0] == '# file GENERATED by distutils, do NOT edit'

    @pytest.mark.usefixtures('needs_zlib')
    def test_manifest_comments(self):
        # make sure comments don't cause exceptions or wrong includes
        contents = dedent(
            """\
            # bad.py
            #bad.py
            good.py
            """
        )
        dist, cmd = self.get_cmd()
        cmd.ensure_finalized()
        self.write_file((self.tmp_dir, cmd.manifest), contents)
        self.write_file((self.tmp_dir, 'good.py'), '# pick me!')
        self.write_file((self.tmp_dir, 'bad.py'), "# don't pick me!")
        self.write_file((self.tmp_dir, '#bad.py'), "# don't pick me!")
        cmd.run()
        assert cmd.filelist.files == ['good.py']

    @pytest.mark.usefixtures('needs_zlib')
    def test_manual_manifest(self):
        # check that a MANIFEST without a marker is left alone
        dist, cmd = self.get_cmd()
        cmd.formats = ['gztar']
        cmd.ensure_finalized()
        self.write_file((self.tmp_dir, cmd.manifest), 'README.manual')
        self.write_file(
            (self.tmp_dir, 'README.manual'),
            'This project maintains its MANIFEST file itself.',
        )
        cmd.run()
        assert cmd.filelist.files == ['README.manual']

        f = open(cmd.manifest)
        try:
            manifest = [
                line.strip() for line in f.read().split('\n') if line.strip() != ''
            ]
        finally:
            f.close()

        assert manifest == ['README.manual']

        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
        archive = tarfile.open(archive_name)
        try:
            filenames = [tarinfo.name for tarinfo in archive]
        finally:
            archive.close()
        assert sorted(filenames) == [
            'fake-1.0',
            'fake-1.0/PKG-INFO',
            'fake-1.0/README.manual',
        ]

    @pytest.mark.usefixtures('needs_zlib')
    @require_unix_id
    @require_uid_0
    @pytest.mark.skipif("not find_executable('tar')")
    @pytest.mark.skipif("not find_executable('gzip')")
    def test_make_distribution_owner_group(self):
        # now building a sdist
        dist, cmd = self.get_cmd()

        # creating a gztar and specifying the owner+group
        cmd.formats = ['gztar']
        cmd.owner = pwd.getpwuid(0)[0]
        cmd.group = grp.getgrgid(0)[0]
        cmd.ensure_finalized()
        cmd.run()

        # making sure we have the good rights
        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
        archive = tarfile.open(archive_name)
        try:
            for member in archive.getmembers():
                assert member.uid == 0
                assert member.gid == 0
        finally:
            archive.close()

        # building a sdist again
        dist, cmd = self.get_cmd()

        # creating a gztar
        cmd.formats = ['gztar']
        cmd.ensure_finalized()
        cmd.run()

        # making sure we have the good rights
        archive_name = join(self.tmp_dir, 'dist', 'fake-1.0.tar.gz')
        archive = tarfile.open(archive_name)

        # note that we are not testing the group ownership here
        # because, depending on the platforms and the container
        # rights (see #7408)
        try:
            for member in archive.getmembers():
                assert member.uid == os.getuid()
        finally:
            archive.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_spawn.py0000644000175100001730000001054614467657412023767 0ustar00runnerdocker"""Tests for distutils.spawn."""
import os
import stat
import sys
import unittest.mock as mock

from test.support import unix_shell

import path

from . import py38compat as os_helper

from distutils.spawn import find_executable
from distutils.spawn import spawn
from distutils.errors import DistutilsExecError
from distutils.tests import support
import pytest


class TestSpawn(support.TempdirManager):
    @pytest.mark.skipif("os.name not in ('nt', 'posix')")
    def test_spawn(self):
        tmpdir = self.mkdtemp()

        # creating something executable
        # through the shell that returns 1
        if sys.platform != 'win32':
            exe = os.path.join(tmpdir, 'foo.sh')
            self.write_file(exe, '#!%s\nexit 1' % unix_shell)
        else:
            exe = os.path.join(tmpdir, 'foo.bat')
            self.write_file(exe, 'exit 1')

        os.chmod(exe, 0o777)
        with pytest.raises(DistutilsExecError):
            spawn([exe])

        # now something that works
        if sys.platform != 'win32':
            exe = os.path.join(tmpdir, 'foo.sh')
            self.write_file(exe, '#!%s\nexit 0' % unix_shell)
        else:
            exe = os.path.join(tmpdir, 'foo.bat')
            self.write_file(exe, 'exit 0')

        os.chmod(exe, 0o777)
        spawn([exe])  # should work without any error

    def test_find_executable(self, tmp_path):
        program_noeext = 'program'
        # Give the temporary program an ".exe" suffix for all.
        # It's needed on Windows and not harmful on other platforms.
        program = program_noeext + ".exe"

        program_path = tmp_path / program
        program_path.write_text("")
        program_path.chmod(stat.S_IXUSR)
        filename = str(program_path)
        tmp_dir = path.Path(tmp_path)

        # test path parameter
        rv = find_executable(program, path=tmp_dir)
        assert rv == filename

        if sys.platform == 'win32':
            # test without ".exe" extension
            rv = find_executable(program_noeext, path=tmp_dir)
            assert rv == filename

        # test find in the current directory
        with tmp_dir:
            rv = find_executable(program)
            assert rv == program

        # test non-existent program
        dont_exist_program = "dontexist_" + program
        rv = find_executable(dont_exist_program, path=tmp_dir)
        assert rv is None

        # PATH='': no match, except in the current directory
        with os_helper.EnvironmentVarGuard() as env:
            env['PATH'] = ''
            with mock.patch(
                'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
            ), mock.patch('distutils.spawn.os.defpath', tmp_dir):
                rv = find_executable(program)
                assert rv is None

                # look in current directory
                with tmp_dir:
                    rv = find_executable(program)
                    assert rv == program

        # PATH=':': explicitly looks in the current directory
        with os_helper.EnvironmentVarGuard() as env:
            env['PATH'] = os.pathsep
            with mock.patch(
                'distutils.spawn.os.confstr', return_value='', create=True
            ), mock.patch('distutils.spawn.os.defpath', ''):
                rv = find_executable(program)
                assert rv is None

                # look in current directory
                with tmp_dir:
                    rv = find_executable(program)
                    assert rv == program

        # missing PATH: test os.confstr("CS_PATH") and os.defpath
        with os_helper.EnvironmentVarGuard() as env:
            env.pop('PATH', None)

            # without confstr
            with mock.patch(
                'distutils.spawn.os.confstr', side_effect=ValueError, create=True
            ), mock.patch('distutils.spawn.os.defpath', tmp_dir):
                rv = find_executable(program)
                assert rv == filename

            # with confstr
            with mock.patch(
                'distutils.spawn.os.confstr', return_value=tmp_dir, create=True
            ), mock.patch('distutils.spawn.os.defpath', ''):
                rv = find_executable(program)
                assert rv == filename

    def test_spawn_missing_exe(self):
        with pytest.raises(DistutilsExecError) as ctx:
            spawn(['does-not-exist'])
        assert "command 'does-not-exist' failed" in str(ctx.value)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_sysconfig.py0000644000175100001730000002743214467657412024645 0ustar00runnerdocker"""Tests for distutils.sysconfig."""
import contextlib
import os
import subprocess
import sys
import pathlib

import pytest
import jaraco.envs
import path
from jaraco.text import trim

import distutils
from distutils import sysconfig
from distutils.ccompiler import get_default_compiler  # noqa: F401
from distutils.unixccompiler import UnixCCompiler
from test.support import swap_item

from . import py37compat


@pytest.mark.usefixtures('save_env')
class TestSysconfig:
    def test_get_config_h_filename(self):
        config_h = sysconfig.get_config_h_filename()
        assert os.path.isfile(config_h)

    @pytest.mark.skipif("platform.system() == 'Windows'")
    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
    def test_get_makefile_filename(self):
        makefile = sysconfig.get_makefile_filename()
        assert os.path.isfile(makefile)

    def test_get_python_lib(self, tmp_path):
        assert sysconfig.get_python_lib() != sysconfig.get_python_lib(prefix=tmp_path)

    def test_get_config_vars(self):
        cvars = sysconfig.get_config_vars()
        assert isinstance(cvars, dict)
        assert cvars

    @pytest.mark.skipif('sysconfig.IS_PYPY')
    @pytest.mark.skipif('sysconfig.python_build')
    @pytest.mark.xfail('platform.system() == "Windows"')
    def test_srcdir_simple(self):
        # See #15364.
        srcdir = pathlib.Path(sysconfig.get_config_var('srcdir'))

        assert srcdir.absolute()
        assert srcdir.is_dir()

        makefile = pathlib.Path(sysconfig.get_makefile_filename())
        assert makefile.parent.samefile(srcdir)

    @pytest.mark.skipif('sysconfig.IS_PYPY')
    @pytest.mark.skipif('not sysconfig.python_build')
    def test_srcdir_python_build(self):
        # See #15364.
        srcdir = pathlib.Path(sysconfig.get_config_var('srcdir'))

        # The python executable has not been installed so srcdir
        # should be a full source checkout.
        Python_h = srcdir.joinpath('Include', 'Python.h')
        assert Python_h.is_file()
        assert sysconfig._is_python_source_dir(srcdir)
        assert sysconfig._is_python_source_dir(str(srcdir))

    def test_srcdir_independent_of_cwd(self):
        """
        srcdir should be independent of the current working directory
        """
        # See #15364.
        srcdir = sysconfig.get_config_var('srcdir')
        with path.Path('..'):
            srcdir2 = sysconfig.get_config_var('srcdir')
        assert srcdir == srcdir2

    def customize_compiler(self):
        # make sure AR gets caught
        class compiler:
            compiler_type = 'unix'
            executables = UnixCCompiler.executables

            def __init__(self):
                self.exes = {}

            def set_executables(self, **kw):
                for k, v in kw.items():
                    self.exes[k] = v

        sysconfig_vars = {
            'AR': 'sc_ar',
            'CC': 'sc_cc',
            'CXX': 'sc_cxx',
            'ARFLAGS': '--sc-arflags',
            'CFLAGS': '--sc-cflags',
            'CCSHARED': '--sc-ccshared',
            'LDSHARED': 'sc_ldshared',
            'SHLIB_SUFFIX': 'sc_shutil_suffix',
            # On macOS, disable _osx_support.customize_compiler()
            'CUSTOMIZED_OSX_COMPILER': 'True',
        }

        comp = compiler()
        with contextlib.ExitStack() as cm:
            for key, value in sysconfig_vars.items():
                cm.enter_context(swap_item(sysconfig._config_vars, key, value))
            sysconfig.customize_compiler(comp)

        return comp

    @pytest.mark.skipif("get_default_compiler() != 'unix'")
    def test_customize_compiler(self):
        # Make sure that sysconfig._config_vars is initialized
        sysconfig.get_config_vars()

        os.environ['AR'] = 'env_ar'
        os.environ['CC'] = 'env_cc'
        os.environ['CPP'] = 'env_cpp'
        os.environ['CXX'] = 'env_cxx --env-cxx-flags'
        os.environ['LDSHARED'] = 'env_ldshared'
        os.environ['LDFLAGS'] = '--env-ldflags'
        os.environ['ARFLAGS'] = '--env-arflags'
        os.environ['CFLAGS'] = '--env-cflags'
        os.environ['CPPFLAGS'] = '--env-cppflags'
        os.environ['RANLIB'] = 'env_ranlib'

        comp = self.customize_compiler()
        assert comp.exes['archiver'] == 'env_ar --env-arflags'
        assert comp.exes['preprocessor'] == 'env_cpp --env-cppflags'
        assert comp.exes['compiler'] == 'env_cc --sc-cflags --env-cflags --env-cppflags'
        assert comp.exes['compiler_so'] == (
            'env_cc --sc-cflags ' '--env-cflags ' '--env-cppflags --sc-ccshared'
        )
        assert comp.exes['compiler_cxx'] == 'env_cxx --env-cxx-flags'
        assert comp.exes['linker_exe'] == 'env_cc'
        assert comp.exes['linker_so'] == (
            'env_ldshared --env-ldflags --env-cflags' ' --env-cppflags'
        )
        assert comp.shared_lib_extension == 'sc_shutil_suffix'

        if sys.platform == "darwin":
            assert comp.exes['ranlib'] == 'env_ranlib'
        else:
            assert 'ranlib' not in comp.exes

        del os.environ['AR']
        del os.environ['CC']
        del os.environ['CPP']
        del os.environ['CXX']
        del os.environ['LDSHARED']
        del os.environ['LDFLAGS']
        del os.environ['ARFLAGS']
        del os.environ['CFLAGS']
        del os.environ['CPPFLAGS']
        del os.environ['RANLIB']

        comp = self.customize_compiler()
        assert comp.exes['archiver'] == 'sc_ar --sc-arflags'
        assert comp.exes['preprocessor'] == 'sc_cc -E'
        assert comp.exes['compiler'] == 'sc_cc --sc-cflags'
        assert comp.exes['compiler_so'] == 'sc_cc --sc-cflags --sc-ccshared'
        assert comp.exes['compiler_cxx'] == 'sc_cxx'
        assert comp.exes['linker_exe'] == 'sc_cc'
        assert comp.exes['linker_so'] == 'sc_ldshared'
        assert comp.shared_lib_extension == 'sc_shutil_suffix'
        assert 'ranlib' not in comp.exes

    def test_parse_makefile_base(self, tmp_path):
        makefile = tmp_path / 'Makefile'
        makefile.write_text(
            trim(
                """
                CONFIG_ARGS=  '--arg1=optarg1' 'ENV=LIB'
                VAR=$OTHER
                OTHER=foo
                """
            )
        )
        d = sysconfig.parse_makefile(makefile)
        assert d == {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", 'OTHER': 'foo'}

    def test_parse_makefile_literal_dollar(self, tmp_path):
        makefile = tmp_path / 'Makefile'
        makefile.write_text(
            trim(
                """
                CONFIG_ARGS=  '--arg1=optarg1' 'ENV=\\$$LIB'
                VAR=$OTHER
                OTHER=foo
                """
            )
        )
        d = sysconfig.parse_makefile(makefile)
        assert d == {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", 'OTHER': 'foo'}

    def test_sysconfig_module(self):
        import sysconfig as global_sysconfig

        assert global_sysconfig.get_config_var('CFLAGS') == sysconfig.get_config_var(
            'CFLAGS'
        )
        assert global_sysconfig.get_config_var('LDFLAGS') == sysconfig.get_config_var(
            'LDFLAGS'
        )

    @pytest.mark.skipif("sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER')")
    def test_sysconfig_compiler_vars(self):
        # On OS X, binary installers support extension module building on
        # various levels of the operating system with differing Xcode
        # configurations.  This requires customization of some of the
        # compiler configuration directives to suit the environment on
        # the installed machine.  Some of these customizations may require
        # running external programs and, so, are deferred until needed by
        # the first extension module build.  With Python 3.3, only
        # the Distutils version of sysconfig is used for extension module
        # builds, which happens earlier in the Distutils tests.  This may
        # cause the following tests to fail since no tests have caused
        # the global version of sysconfig to call the customization yet.
        # The solution for now is to simply skip this test in this case.
        # The longer-term solution is to only have one version of sysconfig.

        import sysconfig as global_sysconfig

        if sysconfig.get_config_var('CUSTOMIZED_OSX_COMPILER'):
            pytest.skip('compiler flags customized')
        assert global_sysconfig.get_config_var('LDSHARED') == sysconfig.get_config_var(
            'LDSHARED'
        )
        assert global_sysconfig.get_config_var('CC') == sysconfig.get_config_var('CC')

    @pytest.mark.skipif("not sysconfig.get_config_var('EXT_SUFFIX')")
    def test_SO_deprecation(self):
        with pytest.warns(DeprecationWarning):
            sysconfig.get_config_var('SO')

    def test_customize_compiler_before_get_config_vars(self, tmp_path):
        # Issue #21923: test that a Distribution compiler
        # instance can be called without an explicit call to
        # get_config_vars().
        file = tmp_path / 'file'
        file.write_text(
            trim(
                """
                from distutils.core import Distribution
                config = Distribution().get_command_obj('config')
                # try_compile may pass or it may fail if no compiler
                # is found but it should not raise an exception.
                rc = config.try_compile('int x;')
                """
            )
        )
        p = subprocess.Popen(
            py37compat.subprocess_args(sys.executable, file),
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            universal_newlines=True,
        )
        outs, errs = p.communicate()
        assert 0 == p.returncode, "Subprocess failed: " + outs

    def test_parse_config_h(self):
        config_h = sysconfig.get_config_h_filename()
        input = {}
        with open(config_h, encoding="utf-8") as f:
            result = sysconfig.parse_config_h(f, g=input)
        assert input is result
        with open(config_h, encoding="utf-8") as f:
            result = sysconfig.parse_config_h(f)
        assert isinstance(result, dict)

    @pytest.mark.skipif("platform.system() != 'Windows'")
    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
    def test_win_ext_suffix(self):
        assert sysconfig.get_config_var("EXT_SUFFIX").endswith(".pyd")
        assert sysconfig.get_config_var("EXT_SUFFIX") != ".pyd"

    @pytest.mark.skipif("platform.system() != 'Windows'")
    @pytest.mark.skipif("sys.implementation.name != 'cpython'")
    @pytest.mark.skipif(
        '\\PCbuild\\'.casefold() not in sys.executable.casefold(),
        reason='Need sys.executable to be in a source tree',
    )
    def test_win_build_venv_from_source_tree(self, tmp_path):
        """Ensure distutils.sysconfig detects venvs from source tree builds."""
        env = jaraco.envs.VEnv()
        env.create_opts = env.clean_opts
        env.root = tmp_path
        env.ensure_env()
        cmd = [
            env.exe(),
            "-c",
            "import distutils.sysconfig; print(distutils.sysconfig.python_build)",
        ]
        distutils_path = os.path.dirname(os.path.dirname(distutils.__file__))
        out = subprocess.check_output(
            cmd, env={**os.environ, "PYTHONPATH": distutils_path}
        )
        assert out == "True"

    def test_get_python_inc_missing_config_dir(self, monkeypatch):
        """
        In portable Python installations, the sysconfig will be broken,
        pointing to the directories where the installation was built and
        not where it currently is. In this case, ensure that the missing
        directory isn't used for get_python_inc.

        See pypa/distutils#178.
        """

        def override(name):
            if name == 'INCLUDEPY':
                return '/does-not-exist'
            return sysconfig.get_config_var(name)

        monkeypatch.setattr(sysconfig, 'get_config_var', override)

        assert os.path.exists(sysconfig.get_python_inc())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_text_file.py0000644000175100001730000000624614467657412024624 0ustar00runnerdocker"""Tests for distutils.text_file."""
import os
from distutils.text_file import TextFile
from distutils.tests import support

TEST_DATA = """# test file

line 3 \\
# intervening comment
  continues on next line
"""


class TestTextFile(support.TempdirManager):
    def test_class(self):
        # old tests moved from text_file.__main__
        # so they are really called by the buildbots

        # result 1: no fancy options
        result1 = [
            '# test file\n',
            '\n',
            'line 3 \\\n',
            '# intervening comment\n',
            '  continues on next line\n',
        ]

        # result 2: just strip comments
        result2 = ["\n", "line 3 \\\n", "  continues on next line\n"]

        # result 3: just strip blank lines
        result3 = [
            "# test file\n",
            "line 3 \\\n",
            "# intervening comment\n",
            "  continues on next line\n",
        ]

        # result 4: default, strip comments, blank lines,
        # and trailing whitespace
        result4 = ["line 3 \\", "  continues on next line"]

        # result 5: strip comments and blanks, plus join lines (but don't
        # "collapse" joined lines
        result5 = ["line 3   continues on next line"]

        # result 6: strip comments and blanks, plus join lines (and
        # "collapse" joined lines
        result6 = ["line 3 continues on next line"]

        def test_input(count, description, file, expected_result):
            result = file.readlines()
            assert result == expected_result

        tmpdir = self.mkdtemp()
        filename = os.path.join(tmpdir, "test.txt")
        out_file = open(filename, "w")
        try:
            out_file.write(TEST_DATA)
        finally:
            out_file.close()

        in_file = TextFile(
            filename, strip_comments=0, skip_blanks=0, lstrip_ws=0, rstrip_ws=0
        )
        try:
            test_input(1, "no processing", in_file, result1)
        finally:
            in_file.close()

        in_file = TextFile(
            filename, strip_comments=1, skip_blanks=0, lstrip_ws=0, rstrip_ws=0
        )
        try:
            test_input(2, "strip comments", in_file, result2)
        finally:
            in_file.close()

        in_file = TextFile(
            filename, strip_comments=0, skip_blanks=1, lstrip_ws=0, rstrip_ws=0
        )
        try:
            test_input(3, "strip blanks", in_file, result3)
        finally:
            in_file.close()

        in_file = TextFile(filename)
        try:
            test_input(4, "default processing", in_file, result4)
        finally:
            in_file.close()

        in_file = TextFile(
            filename, strip_comments=1, skip_blanks=1, join_lines=1, rstrip_ws=1
        )
        try:
            test_input(5, "join lines without collapsing", in_file, result5)
        finally:
            in_file.close()

        in_file = TextFile(
            filename,
            strip_comments=1,
            skip_blanks=1,
            join_lines=1,
            rstrip_ws=1,
            collapse_join=1,
        )
        try:
            test_input(6, "join lines with collapsing", in_file, result6)
        finally:
            in_file.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_unixccompiler.py0000644000175100001730000002400514467657412025513 0ustar00runnerdocker"""Tests for distutils.unixccompiler."""
import os
import sys
import unittest.mock as mock

from .py38compat import EnvironmentVarGuard

from distutils import sysconfig
from distutils.errors import DistutilsPlatformError
from distutils.unixccompiler import UnixCCompiler
from distutils.util import _clear_cached_macosx_ver

from . import support
import pytest


@pytest.fixture(autouse=True)
def save_values(monkeypatch):
    monkeypatch.setattr(sys, 'platform', sys.platform)
    monkeypatch.setattr(sysconfig, 'get_config_var', sysconfig.get_config_var)
    monkeypatch.setattr(sysconfig, 'get_config_vars', sysconfig.get_config_vars)


@pytest.fixture(autouse=True)
def compiler_wrapper(request):
    class CompilerWrapper(UnixCCompiler):
        def rpath_foo(self):
            return self.runtime_library_dir_option('/foo')

    request.instance.cc = CompilerWrapper()


class TestUnixCCompiler(support.TempdirManager):
    @pytest.mark.skipif('platform.system == "Windows"')  # noqa: C901
    def test_runtime_libdir_option(self):  # noqa: C901
        # Issue #5900; GitHub Issue #37
        #
        # Ensure RUNPATH is added to extension modules with RPATH if
        # GNU ld is used

        # darwin
        sys.platform = 'darwin'
        darwin_ver_var = 'MACOSX_DEPLOYMENT_TARGET'
        darwin_rpath_flag = '-Wl,-rpath,/foo'
        darwin_lib_flag = '-L/foo'

        # (macOS version from syscfg, macOS version from env var) -> flag
        # Version value of None generates two tests: as None and as empty string
        # Expected flag value of None means an mismatch exception is expected
        darwin_test_cases = [
            ((None, None), darwin_lib_flag),
            ((None, '11'), darwin_rpath_flag),
            (('10', None), darwin_lib_flag),
            (('10.3', None), darwin_lib_flag),
            (('10.3.1', None), darwin_lib_flag),
            (('10.5', None), darwin_rpath_flag),
            (('10.5.1', None), darwin_rpath_flag),
            (('10.3', '10.3'), darwin_lib_flag),
            (('10.3', '10.5'), darwin_rpath_flag),
            (('10.5', '10.3'), darwin_lib_flag),
            (('10.5', '11'), darwin_rpath_flag),
            (('10.4', '10'), None),
        ]

        def make_darwin_gcv(syscfg_macosx_ver):
            def gcv(var):
                if var == darwin_ver_var:
                    return syscfg_macosx_ver
                return "xxx"

            return gcv

        def do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag):
            env = os.environ
            msg = "macOS version = (sysconfig={!r}, env={!r})".format(
                syscfg_macosx_ver,
                env_macosx_ver,
            )

            # Save
            old_gcv = sysconfig.get_config_var
            old_env_macosx_ver = env.get(darwin_ver_var)

            # Setup environment
            _clear_cached_macosx_ver()
            sysconfig.get_config_var = make_darwin_gcv(syscfg_macosx_ver)
            if env_macosx_ver is not None:
                env[darwin_ver_var] = env_macosx_ver
            elif darwin_ver_var in env:
                env.pop(darwin_ver_var)

            # Run the test
            if expected_flag is not None:
                assert self.cc.rpath_foo() == expected_flag, msg
            else:
                with pytest.raises(
                    DistutilsPlatformError, match=darwin_ver_var + r' mismatch'
                ):
                    self.cc.rpath_foo()

            # Restore
            if old_env_macosx_ver is not None:
                env[darwin_ver_var] = old_env_macosx_ver
            elif darwin_ver_var in env:
                env.pop(darwin_ver_var)
            sysconfig.get_config_var = old_gcv
            _clear_cached_macosx_ver()

        for macosx_vers, expected_flag in darwin_test_cases:
            syscfg_macosx_ver, env_macosx_ver = macosx_vers
            do_darwin_test(syscfg_macosx_ver, env_macosx_ver, expected_flag)
            # Bonus test cases with None interpreted as empty string
            if syscfg_macosx_ver is None:
                do_darwin_test("", env_macosx_ver, expected_flag)
            if env_macosx_ver is None:
                do_darwin_test(syscfg_macosx_ver, "", expected_flag)
            if syscfg_macosx_ver is None and env_macosx_ver is None:
                do_darwin_test("", "", expected_flag)

        old_gcv = sysconfig.get_config_var

        # hp-ux
        sys.platform = 'hp-ux'

        def gcv(v):
            return 'xxx'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == ['+s', '-L/foo']

        def gcv(v):
            return 'gcc'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo']

        def gcv(v):
            return 'g++'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == ['-Wl,+s', '-L/foo']

        sysconfig.get_config_var = old_gcv

        # GCC GNULD
        sys.platform = 'bar'

        def gcv(v):
            if v == 'CC':
                return 'gcc'
            elif v == 'GNULD':
                return 'yes'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'

        def gcv(v):
            if v == 'CC':
                return 'gcc -pthread -B /bar'
            elif v == 'GNULD':
                return 'yes'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'

        # GCC non-GNULD
        sys.platform = 'bar'

        def gcv(v):
            if v == 'CC':
                return 'gcc'
            elif v == 'GNULD':
                return 'no'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == '-Wl,-R/foo'

        # GCC GNULD with fully qualified configuration prefix
        # see #7617
        sys.platform = 'bar'

        def gcv(v):
            if v == 'CC':
                return 'x86_64-pc-linux-gnu-gcc-4.4.2'
            elif v == 'GNULD':
                return 'yes'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'

        # non-GCC GNULD
        sys.platform = 'bar'

        def gcv(v):
            if v == 'CC':
                return 'cc'
            elif v == 'GNULD':
                return 'yes'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == '-Wl,--enable-new-dtags,-R/foo'

        # non-GCC non-GNULD
        sys.platform = 'bar'

        def gcv(v):
            if v == 'CC':
                return 'cc'
            elif v == 'GNULD':
                return 'no'

        sysconfig.get_config_var = gcv
        assert self.cc.rpath_foo() == '-Wl,-R/foo'

    @pytest.mark.skipif('platform.system == "Windows"')
    def test_cc_overrides_ldshared(self):
        # Issue #18080:
        # ensure that setting CC env variable also changes default linker
        def gcv(v):
            if v == 'LDSHARED':
                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
            return 'gcc-4.2'

        def gcvs(*args, _orig=sysconfig.get_config_vars):
            if args:
                return list(map(sysconfig.get_config_var, args))
            return _orig()

        sysconfig.get_config_var = gcv
        sysconfig.get_config_vars = gcvs
        with EnvironmentVarGuard() as env:
            env['CC'] = 'my_cc'
            del env['LDSHARED']
            sysconfig.customize_compiler(self.cc)
        assert self.cc.linker_so[0] == 'my_cc'

    @pytest.mark.skipif('platform.system == "Windows"')
    def test_cc_overrides_ldshared_for_cxx_correctly(self):
        """
        Ensure that setting CC env variable also changes default linker
        correctly when building C++ extensions.

        pypa/distutils#126
        """

        def gcv(v):
            if v == 'LDSHARED':
                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
            elif v == 'CXX':
                return 'g++-4.2'
            return 'gcc-4.2'

        def gcvs(*args, _orig=sysconfig.get_config_vars):
            if args:
                return list(map(sysconfig.get_config_var, args))
            return _orig()

        sysconfig.get_config_var = gcv
        sysconfig.get_config_vars = gcvs
        with mock.patch.object(
            self.cc, 'spawn', return_value=None
        ) as mock_spawn, mock.patch.object(
            self.cc, '_need_link', return_value=True
        ), mock.patch.object(
            self.cc, 'mkpath', return_value=None
        ), EnvironmentVarGuard() as env:
            env['CC'] = 'ccache my_cc'
            env['CXX'] = 'my_cxx'
            del env['LDSHARED']
            sysconfig.customize_compiler(self.cc)
            assert self.cc.linker_so[0:2] == ['ccache', 'my_cc']
            self.cc.link(None, [], 'a.out', target_lang='c++')
            call_args = mock_spawn.call_args[0][0]
            expected = ['my_cxx', '-bundle', '-undefined', 'dynamic_lookup']
            assert call_args[:4] == expected

    @pytest.mark.skipif('platform.system == "Windows"')
    def test_explicit_ldshared(self):
        # Issue #18080:
        # ensure that setting CC env variable does not change
        #   explicit LDSHARED setting for linker
        def gcv(v):
            if v == 'LDSHARED':
                return 'gcc-4.2 -bundle -undefined dynamic_lookup '
            return 'gcc-4.2'

        def gcvs(*args, _orig=sysconfig.get_config_vars):
            if args:
                return list(map(sysconfig.get_config_var, args))
            return _orig()

        sysconfig.get_config_var = gcv
        sysconfig.get_config_vars = gcvs
        with EnvironmentVarGuard() as env:
            env['CC'] = 'my_cc'
            env['LDSHARED'] = 'my_ld -bundle -dynamic'
            sysconfig.customize_compiler(self.cc)
        assert self.cc.linker_so[0] == 'my_ld'

    def test_has_function(self):
        # Issue https://github.com/pypa/distutils/issues/64:
        # ensure that setting output_dir does not raise
        # FileNotFoundError: [Errno 2] No such file or directory: 'a.out'
        self.cc.output_dir = 'scratch'
        os.chdir(self.mkdtemp())
        self.cc.has_function('abort')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_upload.py0000644000175100001730000001475114467657412024125 0ustar00runnerdocker"""Tests for distutils.command.upload."""
import os
import unittest.mock as mock
from urllib.request import HTTPError


from distutils.command import upload as upload_mod
from distutils.command.upload import upload
from distutils.core import Distribution
from distutils.errors import DistutilsError

from distutils.tests.test_config import PYPIRC, BasePyPIRCCommandTestCase
import pytest

PYPIRC_LONG_PASSWORD = """\
[distutils]

index-servers =
    server1
    server2

[server1]
username:me
password:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa

[server2]
username:meagain
password: secret
realm:acme
repository:http://another.pypi/
"""


PYPIRC_NOPASSWORD = """\
[distutils]

index-servers =
    server1

[server1]
username:me
"""


class FakeOpen:
    def __init__(self, url, msg=None, code=None):
        self.url = url
        if not isinstance(url, str):
            self.req = url
        else:
            self.req = None
        self.msg = msg or 'OK'
        self.code = code or 200

    def getheader(self, name, default=None):
        return {
            'content-type': 'text/plain; charset=utf-8',
        }.get(name.lower(), default)

    def read(self):
        return b'xyzzy'

    def getcode(self):
        return self.code


@pytest.fixture(autouse=True)
def urlopen(request, monkeypatch):
    self = request.instance
    monkeypatch.setattr(upload_mod, 'urlopen', self._urlopen)
    self.next_msg = self.next_code = None


class TestUpload(BasePyPIRCCommandTestCase):
    def _urlopen(self, url):
        self.last_open = FakeOpen(url, msg=self.next_msg, code=self.next_code)
        return self.last_open

    def test_finalize_options(self):
        # new format
        self.write_file(self.rc, PYPIRC)
        dist = Distribution()
        cmd = upload(dist)
        cmd.finalize_options()
        for attr, waited in (
            ('username', 'me'),
            ('password', 'secret'),
            ('realm', 'pypi'),
            ('repository', 'https://upload.pypi.org/legacy/'),
        ):
            assert getattr(cmd, attr) == waited

    def test_saved_password(self):
        # file with no password
        self.write_file(self.rc, PYPIRC_NOPASSWORD)

        # make sure it passes
        dist = Distribution()
        cmd = upload(dist)
        cmd.finalize_options()
        assert cmd.password is None

        # make sure we get it as well, if another command
        # initialized it at the dist level
        dist.password = 'xxx'
        cmd = upload(dist)
        cmd.finalize_options()
        assert cmd.password == 'xxx'

    def test_upload(self, caplog):
        tmp = self.mkdtemp()
        path = os.path.join(tmp, 'xxx')
        self.write_file(path)
        command, pyversion, filename = 'xxx', '2.6', path
        dist_files = [(command, pyversion, filename)]
        self.write_file(self.rc, PYPIRC_LONG_PASSWORD)

        # lets run it
        pkg_dir, dist = self.create_dist(dist_files=dist_files)
        cmd = upload(dist)
        cmd.show_response = 1
        cmd.ensure_finalized()
        cmd.run()

        # what did we send ?
        headers = dict(self.last_open.req.headers)
        assert int(headers['Content-length']) >= 2162
        content_type = headers['Content-type']
        assert content_type.startswith('multipart/form-data')
        assert self.last_open.req.get_method() == 'POST'
        expected_url = 'https://upload.pypi.org/legacy/'
        assert self.last_open.req.get_full_url() == expected_url
        data = self.last_open.req.data
        assert b'xxx' in data
        assert b'protocol_version' in data
        assert b'sha256_digest' in data
        assert (
            b'cd2eb0837c9b4c962c22d2ff8b5441b7b45805887f051d39bf133b583baf'
            b'6860' in data
        )
        if b'md5_digest' in data:
            assert b'f561aaf6ef0bf14d4208bb46a4ccb3ad' in data
        if b'blake2_256_digest' in data:
            assert (
                b'b6f289a27d4fe90da63c503bfe0a9b761a8f76bb86148565065f040be'
                b'6d1c3044cf7ded78ef800509bccb4b648e507d88dc6383d67642aadcc'
                b'ce443f1534330a' in data
            )

        # The PyPI response body was echoed
        results = caplog.messages
        assert results[-1] == 75 * '-' + '\nxyzzy\n' + 75 * '-'

    # bpo-32304: archives whose last byte was b'\r' were corrupted due to
    # normalization intended for Mac OS 9.
    def test_upload_correct_cr(self):
        # content that ends with \r should not be modified.
        tmp = self.mkdtemp()
        path = os.path.join(tmp, 'xxx')
        self.write_file(path, content='yy\r')
        command, pyversion, filename = 'xxx', '2.6', path
        dist_files = [(command, pyversion, filename)]
        self.write_file(self.rc, PYPIRC_LONG_PASSWORD)

        # other fields that ended with \r used to be modified, now are
        # preserved.
        pkg_dir, dist = self.create_dist(
            dist_files=dist_files, description='long description\r'
        )
        cmd = upload(dist)
        cmd.show_response = 1
        cmd.ensure_finalized()
        cmd.run()

        headers = dict(self.last_open.req.headers)
        assert int(headers['Content-length']) >= 2172
        assert b'long description\r' in self.last_open.req.data

    def test_upload_fails(self, caplog):
        self.next_msg = "Not Found"
        self.next_code = 404
        with pytest.raises(DistutilsError):
            self.test_upload(caplog)

    @pytest.mark.parametrize(
        'exception,expected,raised_exception',
        [
            (OSError('oserror'), 'oserror', OSError),
            pytest.param(
                HTTPError('url', 400, 'httperror', {}, None),
                'Upload failed (400): httperror',
                DistutilsError,
                id="HTTP 400",
            ),
        ],
    )
    def test_wrong_exception_order(self, exception, expected, raised_exception, caplog):
        tmp = self.mkdtemp()
        path = os.path.join(tmp, 'xxx')
        self.write_file(path)
        dist_files = [('xxx', '2.6', path)]  # command, pyversion, filename
        self.write_file(self.rc, PYPIRC_LONG_PASSWORD)

        pkg_dir, dist = self.create_dist(dist_files=dist_files)

        with mock.patch(
            'distutils.command.upload.urlopen',
            new=mock.Mock(side_effect=exception),
        ):
            with pytest.raises(raised_exception):
                cmd = upload(dist)
                cmd.ensure_finalized()
                cmd.run()
            results = caplog.messages
            assert expected in results[-1]
            caplog.clear()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_util.py0000644000175100001730000001453114467657412023612 0ustar00runnerdocker"""Tests for distutils.util."""
import os
import sys
import sysconfig as stdlib_sysconfig
import unittest.mock as mock
from copy import copy

import pytest

from distutils.util import (
    get_platform,
    convert_path,
    change_root,
    check_environ,
    split_quoted,
    strtobool,
    rfc822_escape,
    byte_compile,
    grok_environment_error,
    get_host_platform,
)
from distutils import util
from distutils import sysconfig
from distutils.errors import DistutilsPlatformError, DistutilsByteCompileError


@pytest.fixture(autouse=True)
def environment(monkeypatch):
    monkeypatch.setattr(os, 'name', os.name)
    monkeypatch.setattr(sys, 'platform', sys.platform)
    monkeypatch.setattr(sys, 'version', sys.version)
    monkeypatch.setattr(os, 'sep', os.sep)
    monkeypatch.setattr(os.path, 'join', os.path.join)
    monkeypatch.setattr(os.path, 'isabs', os.path.isabs)
    monkeypatch.setattr(os.path, 'splitdrive', os.path.splitdrive)
    monkeypatch.setattr(sysconfig, '_config_vars', copy(sysconfig._config_vars))


@pytest.mark.usefixtures('save_env')
class TestUtil:
    def test_get_host_platform(self):
        with mock.patch('os.name', 'nt'):
            with mock.patch('sys.version', '... [... (ARM64)]'):
                assert get_host_platform() == 'win-arm64'
            with mock.patch('sys.version', '... [... (ARM)]'):
                assert get_host_platform() == 'win-arm32'

        with mock.patch('sys.version_info', (3, 9, 0, 'final', 0)):
            assert get_host_platform() == stdlib_sysconfig.get_platform()

    def test_get_platform(self):
        with mock.patch('os.name', 'nt'):
            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x86'}):
                assert get_platform() == 'win32'
            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'x64'}):
                assert get_platform() == 'win-amd64'
            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm'}):
                assert get_platform() == 'win-arm32'
            with mock.patch.dict('os.environ', {'VSCMD_ARG_TGT_ARCH': 'arm64'}):
                assert get_platform() == 'win-arm64'

    def test_convert_path(self):
        # linux/mac
        os.sep = '/'

        def _join(path):
            return '/'.join(path)

        os.path.join = _join

        assert convert_path('/home/to/my/stuff') == '/home/to/my/stuff'

        # win
        os.sep = '\\'

        def _join(*path):
            return '\\'.join(path)

        os.path.join = _join

        with pytest.raises(ValueError):
            convert_path('/home/to/my/stuff')
        with pytest.raises(ValueError):
            convert_path('home/to/my/stuff/')

        assert convert_path('home/to/my/stuff') == 'home\\to\\my\\stuff'
        assert convert_path('.') == os.curdir

    def test_change_root(self):
        # linux/mac
        os.name = 'posix'

        def _isabs(path):
            return path[0] == '/'

        os.path.isabs = _isabs

        def _join(*path):
            return '/'.join(path)

        os.path.join = _join

        assert change_root('/root', '/old/its/here') == '/root/old/its/here'
        assert change_root('/root', 'its/here') == '/root/its/here'

        # windows
        os.name = 'nt'

        def _isabs(path):
            return path.startswith('c:\\')

        os.path.isabs = _isabs

        def _splitdrive(path):
            if path.startswith('c:'):
                return ('', path.replace('c:', ''))
            return ('', path)

        os.path.splitdrive = _splitdrive

        def _join(*path):
            return '\\'.join(path)

        os.path.join = _join

        assert (
            change_root('c:\\root', 'c:\\old\\its\\here') == 'c:\\root\\old\\its\\here'
        )
        assert change_root('c:\\root', 'its\\here') == 'c:\\root\\its\\here'

        # BugsBunny os (it's a great os)
        os.name = 'BugsBunny'
        with pytest.raises(DistutilsPlatformError):
            change_root('c:\\root', 'its\\here')

        # XXX platforms to be covered: mac

    def test_check_environ(self):
        util.check_environ.cache_clear()
        os.environ.pop('HOME', None)

        check_environ()

        assert os.environ['PLAT'] == get_platform()

    @pytest.mark.skipif("os.name != 'posix'")
    def test_check_environ_getpwuid(self):
        util.check_environ.cache_clear()
        os.environ.pop('HOME', None)

        import pwd

        # only set pw_dir field, other fields are not used
        result = pwd.struct_passwd(
            (None, None, None, None, None, '/home/distutils', None)
        )
        with mock.patch.object(pwd, 'getpwuid', return_value=result):
            check_environ()
            assert os.environ['HOME'] == '/home/distutils'

        util.check_environ.cache_clear()
        os.environ.pop('HOME', None)

        # bpo-10496: Catch pwd.getpwuid() error
        with mock.patch.object(pwd, 'getpwuid', side_effect=KeyError):
            check_environ()
            assert 'HOME' not in os.environ

    def test_split_quoted(self):
        assert split_quoted('""one"" "two" \'three\' \\four') == [
            'one',
            'two',
            'three',
            'four',
        ]

    def test_strtobool(self):
        yes = ('y', 'Y', 'yes', 'True', 't', 'true', 'True', 'On', 'on', '1')
        no = ('n', 'no', 'f', 'false', 'off', '0', 'Off', 'No', 'N')

        for y in yes:
            assert strtobool(y)

        for n in no:
            assert not strtobool(n)

    def test_rfc822_escape(self):
        header = 'I am a\npoor\nlonesome\nheader\n'
        res = rfc822_escape(header)
        wanted = ('I am a%(8s)spoor%(8s)slonesome%(8s)s' 'header%(8s)s') % {
            '8s': '\n' + 8 * ' '
        }
        assert res == wanted

    def test_dont_write_bytecode(self):
        # makes sure byte_compile raise a DistutilsError
        # if sys.dont_write_bytecode is True
        old_dont_write_bytecode = sys.dont_write_bytecode
        sys.dont_write_bytecode = True
        try:
            with pytest.raises(DistutilsByteCompileError):
                byte_compile([])
        finally:
            sys.dont_write_bytecode = old_dont_write_bytecode

    def test_grok_environment_error(self):
        # test obsolete function to ensure backward compat (#4931)
        exc = IOError("Unable to find batch file")
        msg = grok_environment_error(exc)
        assert msg == "error: Unable to find batch file"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_version.py0000644000175100001730000000573314467657412024326 0ustar00runnerdocker"""Tests for distutils.version."""
import pytest

import distutils
from distutils.version import LooseVersion
from distutils.version import StrictVersion


@pytest.fixture(autouse=True)
def suppress_deprecation():
    with distutils.version.suppress_known_deprecation():
        yield


class TestVersion:
    def test_prerelease(self):
        version = StrictVersion('1.2.3a1')
        assert version.version == (1, 2, 3)
        assert version.prerelease == ('a', 1)
        assert str(version) == '1.2.3a1'

        version = StrictVersion('1.2.0')
        assert str(version) == '1.2'

    def test_cmp_strict(self):
        versions = (
            ('1.5.1', '1.5.2b2', -1),
            ('161', '3.10a', ValueError),
            ('8.02', '8.02', 0),
            ('3.4j', '1996.07.12', ValueError),
            ('3.2.pl0', '3.1.1.6', ValueError),
            ('2g6', '11g', ValueError),
            ('0.9', '2.2', -1),
            ('1.2.1', '1.2', 1),
            ('1.1', '1.2.2', -1),
            ('1.2', '1.1', 1),
            ('1.2.1', '1.2.2', -1),
            ('1.2.2', '1.2', 1),
            ('1.2', '1.2.2', -1),
            ('0.4.0', '0.4', 0),
            ('1.13++', '5.5.kw', ValueError),
        )

        for v1, v2, wanted in versions:
            try:
                res = StrictVersion(v1)._cmp(StrictVersion(v2))
            except ValueError:
                if wanted is ValueError:
                    continue
                else:
                    raise AssertionError(
                        ("cmp(%s, %s) " "shouldn't raise ValueError") % (v1, v2)
                    )
            assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
                v1, v2, wanted, res
            )
            res = StrictVersion(v1)._cmp(v2)
            assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
                v1, v2, wanted, res
            )
            res = StrictVersion(v1)._cmp(object())
            assert (
                res is NotImplemented
            ), 'cmp({}, {}) should be NotImplemented, got {}'.format(v1, v2, res)

    def test_cmp(self):
        versions = (
            ('1.5.1', '1.5.2b2', -1),
            ('161', '3.10a', 1),
            ('8.02', '8.02', 0),
            ('3.4j', '1996.07.12', -1),
            ('3.2.pl0', '3.1.1.6', 1),
            ('2g6', '11g', -1),
            ('0.960923', '2.2beta29', -1),
            ('1.13++', '5.5.kw', -1),
        )

        for v1, v2, wanted in versions:
            res = LooseVersion(v1)._cmp(LooseVersion(v2))
            assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
                v1, v2, wanted, res
            )
            res = LooseVersion(v1)._cmp(v2)
            assert res == wanted, 'cmp({}, {}) should be {}, got {}'.format(
                v1, v2, wanted, res
            )
            res = LooseVersion(v1)._cmp(object())
            assert (
                res is NotImplemented
            ), 'cmp({}, {}) should be NotImplemented, got {}'.format(v1, v2, res)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/test_versionpredicate.py0000644000175100001730000000000014467657412026165 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/tests/unix_compat.py0000644000175100001730000000060314467657412024117 0ustar00runnerdockerimport sys

try:
    import grp
    import pwd
except ImportError:
    grp = pwd = None

import pytest


UNIX_ID_SUPPORT = grp and pwd
UID_0_SUPPORT = UNIX_ID_SUPPORT and sys.platform != "cygwin"

require_unix_id = pytest.mark.skipif(
    not UNIX_ID_SUPPORT, reason="Requires grp and pwd support"
)
require_uid_0 = pytest.mark.skipif(not UID_0_SUPPORT, reason="Requires UID 0 support")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/text_file.py0000644000175100001730000002746514467657412022431 0ustar00runnerdocker"""text_file

provides the TextFile class, which gives an interface to text files
that (optionally) takes care of stripping comments, ignoring blank
lines, and joining lines with backslashes."""

import sys


class TextFile:
    """Provides a file-like object that takes care of all the things you
    commonly want to do when processing a text file that has some
    line-by-line syntax: strip comments (as long as "#" is your
    comment character), skip blank lines, join adjacent lines by
    escaping the newline (ie. backslash at end of line), strip
    leading and/or trailing whitespace.  All of these are optional
    and independently controllable.

    Provides a 'warn()' method so you can generate warning messages that
    report physical line number, even if the logical line in question
    spans multiple physical lines.  Also provides 'unreadline()' for
    implementing line-at-a-time lookahead.

    Constructor is called as:

        TextFile (filename=None, file=None, **options)

    It bombs (RuntimeError) if both 'filename' and 'file' are None;
    'filename' should be a string, and 'file' a file object (or
    something that provides 'readline()' and 'close()' methods).  It is
    recommended that you supply at least 'filename', so that TextFile
    can include it in warning messages.  If 'file' is not supplied,
    TextFile creates its own using 'io.open()'.

    The options are all boolean, and affect the value returned by
    'readline()':
      strip_comments [default: true]
        strip from "#" to end-of-line, as well as any whitespace
        leading up to the "#" -- unless it is escaped by a backslash
      lstrip_ws [default: false]
        strip leading whitespace from each line before returning it
      rstrip_ws [default: true]
        strip trailing whitespace (including line terminator!) from
        each line before returning it
      skip_blanks [default: true}
        skip lines that are empty *after* stripping comments and
        whitespace.  (If both lstrip_ws and rstrip_ws are false,
        then some lines may consist of solely whitespace: these will
        *not* be skipped, even if 'skip_blanks' is true.)
      join_lines [default: false]
        if a backslash is the last non-newline character on a line
        after stripping comments and whitespace, join the following line
        to it to form one "logical line"; if N consecutive lines end
        with a backslash, then N+1 physical lines will be joined to
        form one logical line.
      collapse_join [default: false]
        strip leading whitespace from lines that are joined to their
        predecessor; only matters if (join_lines and not lstrip_ws)
      errors [default: 'strict']
        error handler used to decode the file content

    Note that since 'rstrip_ws' can strip the trailing newline, the
    semantics of 'readline()' must differ from those of the builtin file
    object's 'readline()' method!  In particular, 'readline()' returns
    None for end-of-file: an empty string might just be a blank line (or
    an all-whitespace line), if 'rstrip_ws' is true but 'skip_blanks' is
    not."""

    default_options = {
        'strip_comments': 1,
        'skip_blanks': 1,
        'lstrip_ws': 0,
        'rstrip_ws': 1,
        'join_lines': 0,
        'collapse_join': 0,
        'errors': 'strict',
    }

    def __init__(self, filename=None, file=None, **options):
        """Construct a new TextFile object.  At least one of 'filename'
        (a string) and 'file' (a file-like object) must be supplied.
        They keyword argument options are described above and affect
        the values returned by 'readline()'."""
        if filename is None and file is None:
            raise RuntimeError(
                "you must supply either or both of 'filename' and 'file'"
            )

        # set values for all options -- either from client option hash
        # or fallback to default_options
        for opt in self.default_options.keys():
            if opt in options:
                setattr(self, opt, options[opt])
            else:
                setattr(self, opt, self.default_options[opt])

        # sanity check client option hash
        for opt in options.keys():
            if opt not in self.default_options:
                raise KeyError("invalid TextFile option '%s'" % opt)

        if file is None:
            self.open(filename)
        else:
            self.filename = filename
            self.file = file
            self.current_line = 0  # assuming that file is at BOF!

        # 'linebuf' is a stack of lines that will be emptied before we
        # actually read from the file; it's only populated by an
        # 'unreadline()' operation
        self.linebuf = []

    def open(self, filename):
        """Open a new file named 'filename'.  This overrides both the
        'filename' and 'file' arguments to the constructor."""
        self.filename = filename
        self.file = open(self.filename, errors=self.errors)
        self.current_line = 0

    def close(self):
        """Close the current file and forget everything we know about it
        (filename, current line number)."""
        file = self.file
        self.file = None
        self.filename = None
        self.current_line = None
        file.close()

    def gen_error(self, msg, line=None):
        outmsg = []
        if line is None:
            line = self.current_line
        outmsg.append(self.filename + ", ")
        if isinstance(line, (list, tuple)):
            outmsg.append("lines %d-%d: " % tuple(line))
        else:
            outmsg.append("line %d: " % line)
        outmsg.append(str(msg))
        return "".join(outmsg)

    def error(self, msg, line=None):
        raise ValueError("error: " + self.gen_error(msg, line))

    def warn(self, msg, line=None):
        """Print (to stderr) a warning message tied to the current logical
        line in the current file.  If the current logical line in the
        file spans multiple physical lines, the warning refers to the
        whole range, eg. "lines 3-5".  If 'line' supplied, it overrides
        the current line number; it may be a list or tuple to indicate a
        range of physical lines, or an integer for a single physical
        line."""
        sys.stderr.write("warning: " + self.gen_error(msg, line) + "\n")

    def readline(self):  # noqa: C901
        """Read and return a single logical line from the current file (or
        from an internal buffer if lines have previously been "unread"
        with 'unreadline()').  If the 'join_lines' option is true, this
        may involve reading multiple physical lines concatenated into a
        single string.  Updates the current line number, so calling
        'warn()' after 'readline()' emits a warning about the physical
        line(s) just read.  Returns None on end-of-file, since the empty
        string can occur if 'rstrip_ws' is true but 'strip_blanks' is
        not."""
        # If any "unread" lines waiting in 'linebuf', return the top
        # one.  (We don't actually buffer read-ahead data -- lines only
        # get put in 'linebuf' if the client explicitly does an
        # 'unreadline()'.
        if self.linebuf:
            line = self.linebuf[-1]
            del self.linebuf[-1]
            return line

        buildup_line = ''

        while True:
            # read the line, make it None if EOF
            line = self.file.readline()
            if line == '':
                line = None

            if self.strip_comments and line:
                # Look for the first "#" in the line.  If none, never
                # mind.  If we find one and it's the first character, or
                # is not preceded by "\", then it starts a comment --
                # strip the comment, strip whitespace before it, and
                # carry on.  Otherwise, it's just an escaped "#", so
                # unescape it (and any other escaped "#"'s that might be
                # lurking in there) and otherwise leave the line alone.

                pos = line.find("#")
                if pos == -1:  # no "#" -- no comments
                    pass

                # It's definitely a comment -- either "#" is the first
                # character, or it's elsewhere and unescaped.
                elif pos == 0 or line[pos - 1] != "\\":
                    # Have to preserve the trailing newline, because it's
                    # the job of a later step (rstrip_ws) to remove it --
                    # and if rstrip_ws is false, we'd better preserve it!
                    # (NB. this means that if the final line is all comment
                    # and has no trailing newline, we will think that it's
                    # EOF; I think that's OK.)
                    eol = (line[-1] == '\n') and '\n' or ''
                    line = line[0:pos] + eol

                    # If all that's left is whitespace, then skip line
                    # *now*, before we try to join it to 'buildup_line' --
                    # that way constructs like
                    #   hello \\
                    #   # comment that should be ignored
                    #   there
                    # result in "hello there".
                    if line.strip() == "":
                        continue
                else:  # it's an escaped "#"
                    line = line.replace("\\#", "#")

            # did previous line end with a backslash? then accumulate
            if self.join_lines and buildup_line:
                # oops: end of file
                if line is None:
                    self.warn("continuation line immediately precedes " "end-of-file")
                    return buildup_line

                if self.collapse_join:
                    line = line.lstrip()
                line = buildup_line + line

                # careful: pay attention to line number when incrementing it
                if isinstance(self.current_line, list):
                    self.current_line[1] = self.current_line[1] + 1
                else:
                    self.current_line = [self.current_line, self.current_line + 1]
            # just an ordinary line, read it as usual
            else:
                if line is None:  # eof
                    return None

                # still have to be careful about incrementing the line number!
                if isinstance(self.current_line, list):
                    self.current_line = self.current_line[1] + 1
                else:
                    self.current_line = self.current_line + 1

            # strip whitespace however the client wants (leading and
            # trailing, or one or the other, or neither)
            if self.lstrip_ws and self.rstrip_ws:
                line = line.strip()
            elif self.lstrip_ws:
                line = line.lstrip()
            elif self.rstrip_ws:
                line = line.rstrip()

            # blank line (whether we rstrip'ed or not)? skip to next line
            # if appropriate
            if line in ('', '\n') and self.skip_blanks:
                continue

            if self.join_lines:
                if line[-1] == '\\':
                    buildup_line = line[:-1]
                    continue

                if line[-2:] == '\\\n':
                    buildup_line = line[0:-2] + '\n'
                    continue

            # well, I guess there's some actual content there: return it
            return line

    def readlines(self):
        """Read and return the list of all logical lines remaining in the
        current file."""
        lines = []
        while True:
            line = self.readline()
            if line is None:
                return lines
            lines.append(line)

    def unreadline(self, line):
        """Push 'line' (a string) onto an internal buffer that will be
        checked by future 'readline()' calls.  Handy for implementing
        a parser with line-at-a-time lookahead."""
        self.linebuf.append(line)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/unixccompiler.py0000644000175100001730000003636114467657412023322 0ustar00runnerdocker"""distutils.unixccompiler

Contains the UnixCCompiler class, a subclass of CCompiler that handles
the "typical" Unix-style command-line C compiler:
  * macros defined with -Dname[=value]
  * macros undefined with -Uname
  * include search directories specified with -Idir
  * libraries specified with -lllib
  * library search directories specified with -Ldir
  * compile handled by 'cc' (or similar) executable with -c option:
    compiles .c to .o
  * link static library handled by 'ar' command (possibly with 'ranlib')
  * link shared library handled by 'cc -shared'
"""

import os
import sys
import re
import shlex
import itertools

from . import sysconfig
from .dep_util import newer
from .ccompiler import CCompiler, gen_preprocess_options, gen_lib_options
from .errors import DistutilsExecError, CompileError, LibError, LinkError
from ._log import log
from ._macos_compat import compiler_fixup

# XXX Things not currently handled:
#   * optimization/debug/warning flags; we just use whatever's in Python's
#     Makefile and live with it.  Is this adequate?  If not, we might
#     have to have a bunch of subclasses GNUCCompiler, SGICCompiler,
#     SunCCompiler, and I suspect down that road lies madness.
#   * even if we don't know a warning flag from an optimization flag,
#     we need some way for outsiders to feed preprocessor/compiler/linker
#     flags in to us -- eg. a sysadmin might want to mandate certain flags
#     via a site config file, or a user might want to set something for
#     compiling this module distribution only via the setup.py command
#     line, whatever.  As long as these options come from something on the
#     current system, they can be as system-dependent as they like, and we
#     should just happily stuff them into the preprocessor/compiler/linker
#     options and carry on.


def _split_env(cmd):
    """
    For macOS, split command into 'env' portion (if any)
    and the rest of the linker command.

    >>> _split_env(['a', 'b', 'c'])
    ([], ['a', 'b', 'c'])
    >>> _split_env(['/usr/bin/env', 'A=3', 'gcc'])
    (['/usr/bin/env', 'A=3'], ['gcc'])
    """
    pivot = 0
    if os.path.basename(cmd[0]) == "env":
        pivot = 1
        while '=' in cmd[pivot]:
            pivot += 1
    return cmd[:pivot], cmd[pivot:]


def _split_aix(cmd):
    """
    AIX platforms prefix the compiler with the ld_so_aix
    script, so split that from the linker command.

    >>> _split_aix(['a', 'b', 'c'])
    ([], ['a', 'b', 'c'])
    >>> _split_aix(['/bin/foo/ld_so_aix', 'gcc'])
    (['/bin/foo/ld_so_aix'], ['gcc'])
    """
    pivot = os.path.basename(cmd[0]) == 'ld_so_aix'
    return cmd[:pivot], cmd[pivot:]


def _linker_params(linker_cmd, compiler_cmd):
    """
    The linker command usually begins with the compiler
    command (possibly multiple elements), followed by zero or more
    params for shared library building.

    If the LDSHARED env variable overrides the linker command,
    however, the commands may not match.

    Return the best guess of the linker parameters by stripping
    the linker command. If the compiler command does not
    match the linker command, assume the linker command is
    just the first element.

    >>> _linker_params('gcc foo bar'.split(), ['gcc'])
    ['foo', 'bar']
    >>> _linker_params('gcc foo bar'.split(), ['other'])
    ['foo', 'bar']
    >>> _linker_params('ccache gcc foo bar'.split(), 'ccache gcc'.split())
    ['foo', 'bar']
    >>> _linker_params(['gcc'], ['gcc'])
    []
    """
    c_len = len(compiler_cmd)
    pivot = c_len if linker_cmd[:c_len] == compiler_cmd else 1
    return linker_cmd[pivot:]


class UnixCCompiler(CCompiler):
    compiler_type = 'unix'

    # These are used by CCompiler in two places: the constructor sets
    # instance attributes 'preprocessor', 'compiler', etc. from them, and
    # 'set_executable()' allows any of these to be set.  The defaults here
    # are pretty generic; they will probably have to be set by an outsider
    # (eg. using information discovered by the sysconfig about building
    # Python extensions).
    executables = {
        'preprocessor': None,
        'compiler': ["cc"],
        'compiler_so': ["cc"],
        'compiler_cxx': ["cc"],
        'linker_so': ["cc", "-shared"],
        'linker_exe': ["cc"],
        'archiver': ["ar", "-cr"],
        'ranlib': None,
    }

    if sys.platform[:6] == "darwin":
        executables['ranlib'] = ["ranlib"]

    # Needed for the filename generation methods provided by the base
    # class, CCompiler.  NB. whoever instantiates/uses a particular
    # UnixCCompiler instance should set 'shared_lib_ext' -- we set a
    # reasonable common default here, but it's not necessarily used on all
    # Unices!

    src_extensions = [".c", ".C", ".cc", ".cxx", ".cpp", ".m"]
    obj_extension = ".o"
    static_lib_extension = ".a"
    shared_lib_extension = ".so"
    dylib_lib_extension = ".dylib"
    xcode_stub_lib_extension = ".tbd"
    static_lib_format = shared_lib_format = dylib_lib_format = "lib%s%s"
    xcode_stub_lib_format = dylib_lib_format
    if sys.platform == "cygwin":
        exe_extension = ".exe"

    def preprocess(
        self,
        source,
        output_file=None,
        macros=None,
        include_dirs=None,
        extra_preargs=None,
        extra_postargs=None,
    ):
        fixed_args = self._fix_compile_args(None, macros, include_dirs)
        ignore, macros, include_dirs = fixed_args
        pp_opts = gen_preprocess_options(macros, include_dirs)
        pp_args = self.preprocessor + pp_opts
        if output_file:
            pp_args.extend(['-o', output_file])
        if extra_preargs:
            pp_args[:0] = extra_preargs
        if extra_postargs:
            pp_args.extend(extra_postargs)
        pp_args.append(source)

        # reasons to preprocess:
        # - force is indicated
        # - output is directed to stdout
        # - source file is newer than the target
        preprocess = self.force or output_file is None or newer(source, output_file)
        if not preprocess:
            return

        if output_file:
            self.mkpath(os.path.dirname(output_file))

        try:
            self.spawn(pp_args)
        except DistutilsExecError as msg:
            raise CompileError(msg)

    def _compile(self, obj, src, ext, cc_args, extra_postargs, pp_opts):
        compiler_so = compiler_fixup(self.compiler_so, cc_args + extra_postargs)
        try:
            self.spawn(compiler_so + cc_args + [src, '-o', obj] + extra_postargs)
        except DistutilsExecError as msg:
            raise CompileError(msg)

    def create_static_lib(
        self, objects, output_libname, output_dir=None, debug=0, target_lang=None
    ):
        objects, output_dir = self._fix_object_args(objects, output_dir)

        output_filename = self.library_filename(output_libname, output_dir=output_dir)

        if self._need_link(objects, output_filename):
            self.mkpath(os.path.dirname(output_filename))
            self.spawn(self.archiver + [output_filename] + objects + self.objects)

            # Not many Unices required ranlib anymore -- SunOS 4.x is, I
            # think the only major Unix that does.  Maybe we need some
            # platform intelligence here to skip ranlib if it's not
            # needed -- or maybe Python's configure script took care of
            # it for us, hence the check for leading colon.
            if self.ranlib:
                try:
                    self.spawn(self.ranlib + [output_filename])
                except DistutilsExecError as msg:
                    raise LibError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    def link(
        self,
        target_desc,
        objects,
        output_filename,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        objects, output_dir = self._fix_object_args(objects, output_dir)
        fixed_args = self._fix_lib_args(libraries, library_dirs, runtime_library_dirs)
        libraries, library_dirs, runtime_library_dirs = fixed_args

        lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs, libraries)
        if not isinstance(output_dir, (str, type(None))):
            raise TypeError("'output_dir' must be a string or None")
        if output_dir is not None:
            output_filename = os.path.join(output_dir, output_filename)

        if self._need_link(objects, output_filename):
            ld_args = objects + self.objects + lib_opts + ['-o', output_filename]
            if debug:
                ld_args[:0] = ['-g']
            if extra_preargs:
                ld_args[:0] = extra_preargs
            if extra_postargs:
                ld_args.extend(extra_postargs)
            self.mkpath(os.path.dirname(output_filename))
            try:
                # Select a linker based on context: linker_exe when
                # building an executable or linker_so (with shared options)
                # when building a shared library.
                building_exe = target_desc == CCompiler.EXECUTABLE
                linker = (self.linker_exe if building_exe else self.linker_so)[:]

                if target_lang == "c++" and self.compiler_cxx:
                    env, linker_ne = _split_env(linker)
                    aix, linker_na = _split_aix(linker_ne)
                    _, compiler_cxx_ne = _split_env(self.compiler_cxx)
                    _, linker_exe_ne = _split_env(self.linker_exe)

                    params = _linker_params(linker_na, linker_exe_ne)
                    linker = env + aix + compiler_cxx_ne + params

                linker = compiler_fixup(linker, ld_args)

                self.spawn(linker + ld_args)
            except DistutilsExecError as msg:
                raise LinkError(msg)
        else:
            log.debug("skipping %s (up-to-date)", output_filename)

    # -- Miscellaneous methods -----------------------------------------
    # These are all used by the 'gen_lib_options() function, in
    # ccompiler.py.

    def library_dir_option(self, dir):
        return "-L" + dir

    def _is_gcc(self):
        cc_var = sysconfig.get_config_var("CC")
        compiler = os.path.basename(shlex.split(cc_var)[0])
        return "gcc" in compiler or "g++" in compiler

    def runtime_library_dir_option(self, dir):
        # XXX Hackish, at the very least.  See Python bug #445902:
        # http://sourceforge.net/tracker/index.php
        #   ?func=detail&aid=445902&group_id=5470&atid=105470
        # Linkers on different platforms need different options to
        # specify that directories need to be added to the list of
        # directories searched for dependencies when a dynamic library
        # is sought.  GCC on GNU systems (Linux, FreeBSD, ...) has to
        # be told to pass the -R option through to the linker, whereas
        # other compilers and gcc on other systems just know this.
        # Other compilers may need something slightly different.  At
        # this time, there's no way to determine this information from
        # the configuration data stored in the Python installation, so
        # we use this hack.
        if sys.platform[:6] == "darwin":
            from distutils.util import get_macosx_target_ver, split_version

            macosx_target_ver = get_macosx_target_ver()
            if macosx_target_ver and split_version(macosx_target_ver) >= [10, 5]:
                return "-Wl,-rpath," + dir
            else:  # no support for -rpath on earlier macOS versions
                return "-L" + dir
        elif sys.platform[:7] == "freebsd":
            return "-Wl,-rpath=" + dir
        elif sys.platform[:5] == "hp-ux":
            return [
                "-Wl,+s" if self._is_gcc() else "+s",
                "-L" + dir,
            ]

        # For all compilers, `-Wl` is the presumed way to
        # pass a compiler option to the linker and `-R` is
        # the way to pass an RPATH.
        if sysconfig.get_config_var("GNULD") == "yes":
            # GNU ld needs an extra option to get a RUNPATH
            # instead of just an RPATH.
            return "-Wl,--enable-new-dtags,-R" + dir
        else:
            return "-Wl,-R" + dir

    def library_option(self, lib):
        return "-l" + lib

    @staticmethod
    def _library_root(dir):
        """
        macOS users can specify an alternate SDK using'-isysroot'.
        Calculate the SDK root if it is specified.

        Note that, as of Xcode 7, Apple SDKs may contain textual stub
        libraries with .tbd extensions rather than the normal .dylib
        shared libraries installed in /.  The Apple compiler tool
        chain handles this transparently but it can cause problems
        for programs that are being built with an SDK and searching
        for specific libraries.  Callers of find_library_file need to
        keep in mind that the base filename of the returned SDK library
        file might have a different extension from that of the library
        file installed on the running system, for example:
          /Applications/Xcode.app/Contents/Developer/Platforms/
              MacOSX.platform/Developer/SDKs/MacOSX10.11.sdk/
              usr/lib/libedit.tbd
        vs
          /usr/lib/libedit.dylib
        """
        cflags = sysconfig.get_config_var('CFLAGS')
        match = re.search(r'-isysroot\s*(\S+)', cflags)

        apply_root = (
            sys.platform == 'darwin'
            and match
            and (
                dir.startswith('/System/')
                or (dir.startswith('/usr/') and not dir.startswith('/usr/local/'))
            )
        )

        return os.path.join(match.group(1), dir[1:]) if apply_root else dir

    def find_library_file(self, dirs, lib, debug=0):
        r"""
        Second-guess the linker with not much hard
        data to go on: GCC seems to prefer the shared library, so
        assume that *all* Unix C compilers do,
        ignoring even GCC's "-static" option.

        >>> compiler = UnixCCompiler()
        >>> compiler._library_root = lambda dir: dir
        >>> monkeypatch = getfixture('monkeypatch')
        >>> monkeypatch.setattr(os.path, 'exists', lambda d: 'existing' in d)
        >>> dirs = ('/foo/bar/missing', '/foo/bar/existing')
        >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
        '/foo/bar/existing/libabc.dylib'
        >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
        '/foo/bar/existing/libabc.dylib'
        >>> monkeypatch.setattr(os.path, 'exists',
        ...     lambda d: 'existing' in d and '.a' in d)
        >>> compiler.find_library_file(dirs, 'abc').replace('\\', '/')
        '/foo/bar/existing/libabc.a'
        >>> compiler.find_library_file(reversed(dirs), 'abc').replace('\\', '/')
        '/foo/bar/existing/libabc.a'
        """
        lib_names = (
            self.library_filename(lib, lib_type=type)
            for type in 'dylib xcode_stub shared static'.split()
        )

        roots = map(self._library_root, dirs)

        searched = (
            os.path.join(root, lib_name)
            for root, lib_name in itertools.product(roots, lib_names)
        )

        found = filter(os.path.exists, searched)

        # Return None if it could not be found in any dir.
        return next(found, None)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/util.py0000644000175100001730000004326314467657412021415 0ustar00runnerdocker"""distutils.util

Miscellaneous utility functions -- anything that doesn't fit into
one of the other *util.py modules.
"""

import importlib.util
import os
import re
import string
import subprocess
import sys
import sysconfig
import functools

from .errors import DistutilsPlatformError, DistutilsByteCompileError
from .dep_util import newer
from .spawn import spawn
from ._log import log


def get_host_platform():
    """
    Return a string that identifies the current platform. Use this
    function to distinguish platform-specific build directories and
    platform-specific built distributions.
    """

    # This function initially exposed platforms as defined in Python 3.9
    # even with older Python versions when distutils was split out.
    # Now it delegates to stdlib sysconfig, but maintains compatibility.

    if sys.version_info < (3, 8):
        if os.name == 'nt':
            if '(arm)' in sys.version.lower():
                return 'win-arm32'
            if '(arm64)' in sys.version.lower():
                return 'win-arm64'

    if sys.version_info < (3, 9):
        if os.name == "posix" and hasattr(os, 'uname'):
            osname, host, release, version, machine = os.uname()
            if osname[:3] == "aix":
                from .py38compat import aix_platform

                return aix_platform(osname, version, release)

    return sysconfig.get_platform()


def get_platform():
    if os.name == 'nt':
        TARGET_TO_PLAT = {
            'x86': 'win32',
            'x64': 'win-amd64',
            'arm': 'win-arm32',
            'arm64': 'win-arm64',
        }
        target = os.environ.get('VSCMD_ARG_TGT_ARCH')
        return TARGET_TO_PLAT.get(target) or get_host_platform()
    return get_host_platform()


if sys.platform == 'darwin':
    _syscfg_macosx_ver = None  # cache the version pulled from sysconfig
MACOSX_VERSION_VAR = 'MACOSX_DEPLOYMENT_TARGET'


def _clear_cached_macosx_ver():
    """For testing only. Do not call."""
    global _syscfg_macosx_ver
    _syscfg_macosx_ver = None


def get_macosx_target_ver_from_syscfg():
    """Get the version of macOS latched in the Python interpreter configuration.
    Returns the version as a string or None if can't obtain one. Cached."""
    global _syscfg_macosx_ver
    if _syscfg_macosx_ver is None:
        from distutils import sysconfig

        ver = sysconfig.get_config_var(MACOSX_VERSION_VAR) or ''
        if ver:
            _syscfg_macosx_ver = ver
    return _syscfg_macosx_ver


def get_macosx_target_ver():
    """Return the version of macOS for which we are building.

    The target version defaults to the version in sysconfig latched at time
    the Python interpreter was built, unless overridden by an environment
    variable. If neither source has a value, then None is returned"""

    syscfg_ver = get_macosx_target_ver_from_syscfg()
    env_ver = os.environ.get(MACOSX_VERSION_VAR)

    if env_ver:
        # Validate overridden version against sysconfig version, if have both.
        # Ensure that the deployment target of the build process is not less
        # than 10.3 if the interpreter was built for 10.3 or later.  This
        # ensures extension modules are built with correct compatibility
        # values, specifically LDSHARED which can use
        # '-undefined dynamic_lookup' which only works on >= 10.3.
        if (
            syscfg_ver
            and split_version(syscfg_ver) >= [10, 3]
            and split_version(env_ver) < [10, 3]
        ):
            my_msg = (
                '$' + MACOSX_VERSION_VAR + ' mismatch: '
                'now "%s" but "%s" during configure; '
                'must use 10.3 or later' % (env_ver, syscfg_ver)
            )
            raise DistutilsPlatformError(my_msg)
        return env_ver
    return syscfg_ver


def split_version(s):
    """Convert a dot-separated string into a list of numbers for comparisons"""
    return [int(n) for n in s.split('.')]


def convert_path(pathname):
    """Return 'pathname' as a name that will work on the native filesystem,
    i.e. split it on '/' and put it back together again using the current
    directory separator.  Needed because filenames in the setup script are
    always supplied in Unix style, and have to be converted to the local
    convention before we can actually use them in the filesystem.  Raises
    ValueError on non-Unix-ish systems if 'pathname' either starts or
    ends with a slash.
    """
    if os.sep == '/':
        return pathname
    if not pathname:
        return pathname
    if pathname[0] == '/':
        raise ValueError("path '%s' cannot be absolute" % pathname)
    if pathname[-1] == '/':
        raise ValueError("path '%s' cannot end with '/'" % pathname)

    paths = pathname.split('/')
    while '.' in paths:
        paths.remove('.')
    if not paths:
        return os.curdir
    return os.path.join(*paths)


# convert_path ()


def change_root(new_root, pathname):
    """Return 'pathname' with 'new_root' prepended.  If 'pathname' is
    relative, this is equivalent to "os.path.join(new_root,pathname)".
    Otherwise, it requires making 'pathname' relative and then joining the
    two, which is tricky on DOS/Windows and Mac OS.
    """
    if os.name == 'posix':
        if not os.path.isabs(pathname):
            return os.path.join(new_root, pathname)
        else:
            return os.path.join(new_root, pathname[1:])

    elif os.name == 'nt':
        (drive, path) = os.path.splitdrive(pathname)
        if path[0] == '\\':
            path = path[1:]
        return os.path.join(new_root, path)

    raise DistutilsPlatformError(f"nothing known about platform '{os.name}'")


@functools.lru_cache()
def check_environ():
    """Ensure that 'os.environ' has all the environment variables we
    guarantee that users can use in config files, command-line options,
    etc.  Currently this includes:
      HOME - user's home directory (Unix only)
      PLAT - description of the current platform, including hardware
             and OS (see 'get_platform()')
    """
    if os.name == 'posix' and 'HOME' not in os.environ:
        try:
            import pwd

            os.environ['HOME'] = pwd.getpwuid(os.getuid())[5]
        except (ImportError, KeyError):
            # bpo-10496: if the current user identifier doesn't exist in the
            # password database, do nothing
            pass

    if 'PLAT' not in os.environ:
        os.environ['PLAT'] = get_platform()


def subst_vars(s, local_vars):
    """
    Perform variable substitution on 'string'.
    Variables are indicated by format-style braces ("{var}").
    Variable is substituted by the value found in the 'local_vars'
    dictionary or in 'os.environ' if it's not in 'local_vars'.
    'os.environ' is first checked/augmented to guarantee that it contains
    certain values: see 'check_environ()'.  Raise ValueError for any
    variables not found in either 'local_vars' or 'os.environ'.
    """
    check_environ()
    lookup = dict(os.environ)
    lookup.update((name, str(value)) for name, value in local_vars.items())
    try:
        return _subst_compat(s).format_map(lookup)
    except KeyError as var:
        raise ValueError(f"invalid variable {var}")


def _subst_compat(s):
    """
    Replace shell/Perl-style variable substitution with
    format-style. For compatibility.
    """

    def _subst(match):
        return f'{{{match.group(1)}}}'

    repl = re.sub(r'\$([a-zA-Z_][a-zA-Z_0-9]*)', _subst, s)
    if repl != s:
        import warnings

        warnings.warn(
            "shell/Perl-style substitutions are deprecated",
            DeprecationWarning,
        )
    return repl


def grok_environment_error(exc, prefix="error: "):
    # Function kept for backward compatibility.
    # Used to try clever things with EnvironmentErrors,
    # but nowadays str(exception) produces good messages.
    return prefix + str(exc)


# Needed by 'split_quoted()'
_wordchars_re = _squote_re = _dquote_re = None


def _init_regex():
    global _wordchars_re, _squote_re, _dquote_re
    _wordchars_re = re.compile(r'[^\\\'\"%s ]*' % string.whitespace)
    _squote_re = re.compile(r"'(?:[^'\\]|\\.)*'")
    _dquote_re = re.compile(r'"(?:[^"\\]|\\.)*"')


def split_quoted(s):
    """Split a string up according to Unix shell-like rules for quotes and
    backslashes.  In short: words are delimited by spaces, as long as those
    spaces are not escaped by a backslash, or inside a quoted string.
    Single and double quotes are equivalent, and the quote characters can
    be backslash-escaped.  The backslash is stripped from any two-character
    escape sequence, leaving only the escaped character.  The quote
    characters are stripped from any quoted string.  Returns a list of
    words.
    """

    # This is a nice algorithm for splitting up a single string, since it
    # doesn't require character-by-character examination.  It was a little
    # bit of a brain-bender to get it working right, though...
    if _wordchars_re is None:
        _init_regex()

    s = s.strip()
    words = []
    pos = 0

    while s:
        m = _wordchars_re.match(s, pos)
        end = m.end()
        if end == len(s):
            words.append(s[:end])
            break

        if s[end] in string.whitespace:
            # unescaped, unquoted whitespace: now
            # we definitely have a word delimiter
            words.append(s[:end])
            s = s[end:].lstrip()
            pos = 0

        elif s[end] == '\\':
            # preserve whatever is being escaped;
            # will become part of the current word
            s = s[:end] + s[end + 1 :]
            pos = end + 1

        else:
            if s[end] == "'":  # slurp singly-quoted string
                m = _squote_re.match(s, end)
            elif s[end] == '"':  # slurp doubly-quoted string
                m = _dquote_re.match(s, end)
            else:
                raise RuntimeError("this can't happen (bad char '%c')" % s[end])

            if m is None:
                raise ValueError("bad string (mismatched %s quotes?)" % s[end])

            (beg, end) = m.span()
            s = s[:beg] + s[beg + 1 : end - 1] + s[end:]
            pos = m.end() - 2

        if pos >= len(s):
            words.append(s)
            break

    return words


# split_quoted ()


def execute(func, args, msg=None, verbose=0, dry_run=0):
    """Perform some action that affects the outside world (eg.  by
    writing to the filesystem).  Such actions are special because they
    are disabled by the 'dry_run' flag.  This method takes care of all
    that bureaucracy for you; all you have to do is supply the
    function to call and an argument tuple for it (to embody the
    "external action" being performed), and an optional message to
    print.
    """
    if msg is None:
        msg = "{}{!r}".format(func.__name__, args)
        if msg[-2:] == ',)':  # correct for singleton tuple
            msg = msg[0:-2] + ')'

    log.info(msg)
    if not dry_run:
        func(*args)


def strtobool(val):
    """Convert a string representation of truth to true (1) or false (0).

    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
    'val' is anything else.
    """
    val = val.lower()
    if val in ('y', 'yes', 't', 'true', 'on', '1'):
        return 1
    elif val in ('n', 'no', 'f', 'false', 'off', '0'):
        return 0
    else:
        raise ValueError("invalid truth value {!r}".format(val))


def byte_compile(  # noqa: C901
    py_files,
    optimize=0,
    force=0,
    prefix=None,
    base_dir=None,
    verbose=1,
    dry_run=0,
    direct=None,
):
    """Byte-compile a collection of Python source files to .pyc
    files in a __pycache__ subdirectory.  'py_files' is a list
    of files to compile; any files that don't end in ".py" are silently
    skipped.  'optimize' must be one of the following:
      0 - don't optimize
      1 - normal optimization (like "python -O")
      2 - extra optimization (like "python -OO")
    If 'force' is true, all files are recompiled regardless of
    timestamps.

    The source filename encoded in each bytecode file defaults to the
    filenames listed in 'py_files'; you can modify these with 'prefix' and
    'basedir'.  'prefix' is a string that will be stripped off of each
    source filename, and 'base_dir' is a directory name that will be
    prepended (after 'prefix' is stripped).  You can supply either or both
    (or neither) of 'prefix' and 'base_dir', as you wish.

    If 'dry_run' is true, doesn't actually do anything that would
    affect the filesystem.

    Byte-compilation is either done directly in this interpreter process
    with the standard py_compile module, or indirectly by writing a
    temporary script and executing it.  Normally, you should let
    'byte_compile()' figure out to use direct compilation or not (see
    the source for details).  The 'direct' flag is used by the script
    generated in indirect mode; unless you know what you're doing, leave
    it set to None.
    """

    # nothing is done if sys.dont_write_bytecode is True
    if sys.dont_write_bytecode:
        raise DistutilsByteCompileError('byte-compiling is disabled.')

    # First, if the caller didn't force us into direct or indirect mode,
    # figure out which mode we should be in.  We take a conservative
    # approach: choose direct mode *only* if the current interpreter is
    # in debug mode and optimize is 0.  If we're not in debug mode (-O
    # or -OO), we don't know which level of optimization this
    # interpreter is running with, so we can't do direct
    # byte-compilation and be certain that it's the right thing.  Thus,
    # always compile indirectly if the current interpreter is in either
    # optimize mode, or if either optimization level was requested by
    # the caller.
    if direct is None:
        direct = __debug__ and optimize == 0

    # "Indirect" byte-compilation: write a temporary script and then
    # run it with the appropriate flags.
    if not direct:
        try:
            from tempfile import mkstemp

            (script_fd, script_name) = mkstemp(".py")
        except ImportError:
            from tempfile import mktemp

            (script_fd, script_name) = None, mktemp(".py")
        log.info("writing byte-compilation script '%s'", script_name)
        if not dry_run:
            if script_fd is not None:
                script = os.fdopen(script_fd, "w")
            else:
                script = open(script_name, "w")

            with script:
                script.write(
                    """\
from distutils.util import byte_compile
files = [
"""
                )

                # XXX would be nice to write absolute filenames, just for
                # safety's sake (script should be more robust in the face of
                # chdir'ing before running it).  But this requires abspath'ing
                # 'prefix' as well, and that breaks the hack in build_lib's
                # 'byte_compile()' method that carefully tacks on a trailing
                # slash (os.sep really) to make sure the prefix here is "just
                # right".  This whole prefix business is rather delicate -- the
                # problem is that it's really a directory, but I'm treating it
                # as a dumb string, so trailing slashes and so forth matter.

                script.write(",\n".join(map(repr, py_files)) + "]\n")
                script.write(
                    """
byte_compile(files, optimize=%r, force=%r,
             prefix=%r, base_dir=%r,
             verbose=%r, dry_run=0,
             direct=1)
"""
                    % (optimize, force, prefix, base_dir, verbose)
                )

        cmd = [sys.executable]
        cmd.extend(subprocess._optim_args_from_interpreter_flags())
        cmd.append(script_name)
        spawn(cmd, dry_run=dry_run)
        execute(os.remove, (script_name,), "removing %s" % script_name, dry_run=dry_run)

    # "Direct" byte-compilation: use the py_compile module to compile
    # right here, right now.  Note that the script generated in indirect
    # mode simply calls 'byte_compile()' in direct mode, a weird sort of
    # cross-process recursion.  Hey, it works!
    else:
        from py_compile import compile

        for file in py_files:
            if file[-3:] != ".py":
                # This lets us be lazy and not filter filenames in
                # the "install_lib" command.
                continue

            # Terminology from the py_compile module:
            #   cfile - byte-compiled file
            #   dfile - purported source filename (same as 'file' by default)
            if optimize >= 0:
                opt = '' if optimize == 0 else optimize
                cfile = importlib.util.cache_from_source(file, optimization=opt)
            else:
                cfile = importlib.util.cache_from_source(file)
            dfile = file
            if prefix:
                if file[: len(prefix)] != prefix:
                    raise ValueError(
                        "invalid prefix: filename %r doesn't start with %r"
                        % (file, prefix)
                    )
                dfile = dfile[len(prefix) :]
            if base_dir:
                dfile = os.path.join(base_dir, dfile)

            cfile_base = os.path.basename(cfile)
            if direct:
                if force or newer(file, cfile):
                    log.info("byte-compiling %s to %s", file, cfile_base)
                    if not dry_run:
                        compile(file, cfile, dfile)
                else:
                    log.debug("skipping byte-compilation of %s to %s", file, cfile_base)


def rfc822_escape(header):
    """Return a version of the string escaped for inclusion in an
    RFC-822 header, by ensuring there are 8 spaces space after each newline.
    """
    lines = header.split('\n')
    sep = '\n' + 8 * ' '
    return sep.join(lines)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/version.py0000644000175100001730000003122714467657412022122 0ustar00runnerdocker#
# distutils/version.py
#
# Implements multiple version numbering conventions for the
# Python Module Distribution Utilities.
#
# $Id$
#

"""Provides classes to represent module version numbers (one class for
each style of version numbering).  There are currently two such classes
implemented: StrictVersion and LooseVersion.

Every version number class implements the following interface:
  * the 'parse' method takes a string and parses it to some internal
    representation; if the string is an invalid version number,
    'parse' raises a ValueError exception
  * the class constructor takes an optional string argument which,
    if supplied, is passed to 'parse'
  * __str__ reconstructs the string that was passed to 'parse' (or
    an equivalent string -- ie. one that will generate an equivalent
    version number instance)
  * __repr__ generates Python code to recreate the version number instance
  * _cmp compares the current instance with either another instance
    of the same class or a string (which will be parsed to an instance
    of the same class, thus must follow the same rules)
"""

import re
import warnings
import contextlib


@contextlib.contextmanager
def suppress_known_deprecation():
    with warnings.catch_warnings(record=True) as ctx:
        warnings.filterwarnings(
            action='default',
            category=DeprecationWarning,
            message="distutils Version classes are deprecated.",
        )
        yield ctx


class Version:
    """Abstract base class for version numbering classes.  Just provides
    constructor (__init__) and reproducer (__repr__), because those
    seem to be the same for all version numbering classes; and route
    rich comparisons to _cmp.
    """

    def __init__(self, vstring=None):
        if vstring:
            self.parse(vstring)
        warnings.warn(
            "distutils Version classes are deprecated. "
            "Use packaging.version instead.",
            DeprecationWarning,
            stacklevel=2,
        )

    def __repr__(self):
        return "{} ('{}')".format(self.__class__.__name__, str(self))

    def __eq__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c == 0

    def __lt__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c < 0

    def __le__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c <= 0

    def __gt__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c > 0

    def __ge__(self, other):
        c = self._cmp(other)
        if c is NotImplemented:
            return c
        return c >= 0


# Interface for version-number classes -- must be implemented
# by the following classes (the concrete ones -- Version should
# be treated as an abstract class).
#    __init__ (string) - create and take same action as 'parse'
#                        (string parameter is optional)
#    parse (string)    - convert a string representation to whatever
#                        internal representation is appropriate for
#                        this style of version numbering
#    __str__ (self)    - convert back to a string; should be very similar
#                        (if not identical to) the string supplied to parse
#    __repr__ (self)   - generate Python code to recreate
#                        the instance
#    _cmp (self, other) - compare two version numbers ('other' may
#                        be an unparsed version string, or another
#                        instance of your version class)


class StrictVersion(Version):

    """Version numbering for anal retentives and software idealists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of two or three
    dot-separated numeric components, with an optional "pre-release" tag
    on the end.  The pre-release tag consists of the letter 'a' or 'b'
    followed by a number.  If the numeric components of two version
    numbers are equal, then one with a pre-release tag will always
    be deemed earlier (lesser) than one without.

    The following are valid version numbers (shown in the order that
    would be obtained by sorting according to the supplied cmp function):

        0.4       0.4.0  (these two are equivalent)
        0.4.1
        0.5a1
        0.5b3
        0.5
        0.9.6
        1.0
        1.0.4a3
        1.0.4b1
        1.0.4

    The following are examples of invalid version numbers:

        1
        2.7.2.2
        1.3.a4
        1.3pl1
        1.3c4

    The rationale for this version numbering system will be explained
    in the distutils documentation.
    """

    version_re = re.compile(
        r'^(\d+) \. (\d+) (\. (\d+))? ([ab](\d+))?$', re.VERBOSE | re.ASCII
    )

    def parse(self, vstring):
        match = self.version_re.match(vstring)
        if not match:
            raise ValueError("invalid version number '%s'" % vstring)

        (major, minor, patch, prerelease, prerelease_num) = match.group(1, 2, 4, 5, 6)

        if patch:
            self.version = tuple(map(int, [major, minor, patch]))
        else:
            self.version = tuple(map(int, [major, minor])) + (0,)

        if prerelease:
            self.prerelease = (prerelease[0], int(prerelease_num))
        else:
            self.prerelease = None

    def __str__(self):
        if self.version[2] == 0:
            vstring = '.'.join(map(str, self.version[0:2]))
        else:
            vstring = '.'.join(map(str, self.version))

        if self.prerelease:
            vstring = vstring + self.prerelease[0] + str(self.prerelease[1])

        return vstring

    def _cmp(self, other):  # noqa: C901
        if isinstance(other, str):
            with suppress_known_deprecation():
                other = StrictVersion(other)
        elif not isinstance(other, StrictVersion):
            return NotImplemented

        if self.version != other.version:
            # numeric versions don't match
            # prerelease stuff doesn't matter
            if self.version < other.version:
                return -1
            else:
                return 1

        # have to compare prerelease
        # case 1: neither has prerelease; they're equal
        # case 2: self has prerelease, other doesn't; other is greater
        # case 3: self doesn't have prerelease, other does: self is greater
        # case 4: both have prerelease: must compare them!

        if not self.prerelease and not other.prerelease:
            return 0
        elif self.prerelease and not other.prerelease:
            return -1
        elif not self.prerelease and other.prerelease:
            return 1
        elif self.prerelease and other.prerelease:
            if self.prerelease == other.prerelease:
                return 0
            elif self.prerelease < other.prerelease:
                return -1
            else:
                return 1
        else:
            assert False, "never get here"


# end class StrictVersion


# The rules according to Greg Stein:
# 1) a version number has 1 or more numbers separated by a period or by
#    sequences of letters. If only periods, then these are compared
#    left-to-right to determine an ordering.
# 2) sequences of letters are part of the tuple for comparison and are
#    compared lexicographically
# 3) recognize the numeric components may have leading zeroes
#
# The LooseVersion class below implements these rules: a version number
# string is split up into a tuple of integer and string components, and
# comparison is a simple tuple comparison.  This means that version
# numbers behave in a predictable and obvious way, but a way that might
# not necessarily be how people *want* version numbers to behave.  There
# wouldn't be a problem if people could stick to purely numeric version
# numbers: just split on period and compare the numbers as tuples.
# However, people insist on putting letters into their version numbers;
# the most common purpose seems to be:
#   - indicating a "pre-release" version
#     ('alpha', 'beta', 'a', 'b', 'pre', 'p')
#   - indicating a post-release patch ('p', 'pl', 'patch')
# but of course this can't cover all version number schemes, and there's
# no way to know what a programmer means without asking him.
#
# The problem is what to do with letters (and other non-numeric
# characters) in a version number.  The current implementation does the
# obvious and predictable thing: keep them as strings and compare
# lexically within a tuple comparison.  This has the desired effect if
# an appended letter sequence implies something "post-release":
# eg. "0.99" < "0.99pl14" < "1.0", and "5.001" < "5.001m" < "5.002".
#
# However, if letters in a version number imply a pre-release version,
# the "obvious" thing isn't correct.  Eg. you would expect that
# "1.5.1" < "1.5.2a2" < "1.5.2", but under the tuple/lexical comparison
# implemented here, this just isn't so.
#
# Two possible solutions come to mind.  The first is to tie the
# comparison algorithm to a particular set of semantic rules, as has
# been done in the StrictVersion class above.  This works great as long
# as everyone can go along with bondage and discipline.  Hopefully a
# (large) subset of Python module programmers will agree that the
# particular flavour of bondage and discipline provided by StrictVersion
# provides enough benefit to be worth using, and will submit their
# version numbering scheme to its domination.  The free-thinking
# anarchists in the lot will never give in, though, and something needs
# to be done to accommodate them.
#
# Perhaps a "moderately strict" version class could be implemented that
# lets almost anything slide (syntactically), and makes some heuristic
# assumptions about non-digits in version number strings.  This could
# sink into special-case-hell, though; if I was as talented and
# idiosyncratic as Larry Wall, I'd go ahead and implement a class that
# somehow knows that "1.2.1" < "1.2.2a2" < "1.2.2" < "1.2.2pl3", and is
# just as happy dealing with things like "2g6" and "1.13++".  I don't
# think I'm smart enough to do it right though.
#
# In any case, I've coded the test suite for this module (see
# ../test/test_version.py) specifically to fail on things like comparing
# "1.2a2" and "1.2".  That's not because the *code* is doing anything
# wrong, it's because the simple, obvious design doesn't match my
# complicated, hairy expectations for real-world version numbers.  It
# would be a snap to fix the test suite to say, "Yep, LooseVersion does
# the Right Thing" (ie. the code matches the conception).  But I'd rather
# have a conception that matches common notions about version numbers.


class LooseVersion(Version):

    """Version numbering for anarchists and software realists.
    Implements the standard interface for version number classes as
    described above.  A version number consists of a series of numbers,
    separated by either periods or strings of letters.  When comparing
    version numbers, the numeric components will be compared
    numerically, and the alphabetic components lexically.  The following
    are all valid version numbers, in no particular order:

        1.5.1
        1.5.2b2
        161
        3.10a
        8.02
        3.4j
        1996.07.12
        3.2.pl0
        3.1.1.6
        2g6
        11g
        0.960923
        2.2beta29
        1.13++
        5.5.kw
        2.0b1pl0

    In fact, there is no such thing as an invalid version number under
    this scheme; the rules for comparison are simple and predictable,
    but may not always give the results you want (for some definition
    of "want").
    """

    component_re = re.compile(r'(\d+ | [a-z]+ | \.)', re.VERBOSE)

    def parse(self, vstring):
        # I've given up on thinking I can reconstruct the version string
        # from the parsed tuple -- so I just store the string here for
        # use by __str__
        self.vstring = vstring
        components = [x for x in self.component_re.split(vstring) if x and x != '.']
        for i, obj in enumerate(components):
            try:
                components[i] = int(obj)
            except ValueError:
                pass

        self.version = components

    def __str__(self):
        return self.vstring

    def __repr__(self):
        return "LooseVersion ('%s')" % str(self)

    def _cmp(self, other):
        if isinstance(other, str):
            other = LooseVersion(other)
        elif not isinstance(other, LooseVersion):
            return NotImplemented

        if self.version == other.version:
            return 0
        if self.version < other.version:
            return -1
        if self.version > other.version:
            return 1


# end class LooseVersion
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_distutils/versionpredicate.py0000644000175100001730000001212514467657412023777 0ustar00runnerdocker"""Module for parsing and testing package version predicate strings.
"""
import re
from . import version
import operator


re_validPackage = re.compile(r"(?i)^\s*([a-z_]\w*(?:\.[a-z_]\w*)*)(.*)", re.ASCII)
# (package) (rest)

re_paren = re.compile(r"^\s*\((.*)\)\s*$")  # (list) inside of parentheses
re_splitComparison = re.compile(r"^\s*(<=|>=|<|>|!=|==)\s*([^\s,]+)\s*$")
# (comp) (version)


def splitUp(pred):
    """Parse a single version comparison.

    Return (comparison string, StrictVersion)
    """
    res = re_splitComparison.match(pred)
    if not res:
        raise ValueError("bad package restriction syntax: %r" % pred)
    comp, verStr = res.groups()
    with version.suppress_known_deprecation():
        other = version.StrictVersion(verStr)
    return (comp, other)


compmap = {
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    ">": operator.gt,
    ">=": operator.ge,
    "!=": operator.ne,
}


class VersionPredicate:
    """Parse and test package version predicates.

    >>> v = VersionPredicate('pyepat.abc (>1.0, <3333.3a1, !=1555.1b3)')

    The `name` attribute provides the full dotted name that is given::

    >>> v.name
    'pyepat.abc'

    The str() of a `VersionPredicate` provides a normalized
    human-readable version of the expression::

    >>> print(v)
    pyepat.abc (> 1.0, < 3333.3a1, != 1555.1b3)

    The `satisfied_by()` method can be used to determine with a given
    version number is included in the set described by the version
    restrictions::

    >>> v.satisfied_by('1.1')
    True
    >>> v.satisfied_by('1.4')
    True
    >>> v.satisfied_by('1.0')
    False
    >>> v.satisfied_by('4444.4')
    False
    >>> v.satisfied_by('1555.1b3')
    False

    `VersionPredicate` is flexible in accepting extra whitespace::

    >>> v = VersionPredicate(' pat( ==  0.1  )  ')
    >>> v.name
    'pat'
    >>> v.satisfied_by('0.1')
    True
    >>> v.satisfied_by('0.2')
    False

    If any version numbers passed in do not conform to the
    restrictions of `StrictVersion`, a `ValueError` is raised::

    >>> v = VersionPredicate('p1.p2.p3.p4(>=1.0, <=1.3a1, !=1.2zb3)')
    Traceback (most recent call last):
      ...
    ValueError: invalid version number '1.2zb3'

    It the module or package name given does not conform to what's
    allowed as a legal module or package name, `ValueError` is
    raised::

    >>> v = VersionPredicate('foo-bar')
    Traceback (most recent call last):
      ...
    ValueError: expected parenthesized list: '-bar'

    >>> v = VersionPredicate('foo bar (12.21)')
    Traceback (most recent call last):
      ...
    ValueError: expected parenthesized list: 'bar (12.21)'

    """

    def __init__(self, versionPredicateStr):
        """Parse a version predicate string."""
        # Fields:
        #    name:  package name
        #    pred:  list of (comparison string, StrictVersion)

        versionPredicateStr = versionPredicateStr.strip()
        if not versionPredicateStr:
            raise ValueError("empty package restriction")
        match = re_validPackage.match(versionPredicateStr)
        if not match:
            raise ValueError("bad package name in %r" % versionPredicateStr)
        self.name, paren = match.groups()
        paren = paren.strip()
        if paren:
            match = re_paren.match(paren)
            if not match:
                raise ValueError("expected parenthesized list: %r" % paren)
            str = match.groups()[0]
            self.pred = [splitUp(aPred) for aPred in str.split(",")]
            if not self.pred:
                raise ValueError("empty parenthesized list in %r" % versionPredicateStr)
        else:
            self.pred = []

    def __str__(self):
        if self.pred:
            seq = [cond + " " + str(ver) for cond, ver in self.pred]
            return self.name + " (" + ", ".join(seq) + ")"
        else:
            return self.name

    def satisfied_by(self, version):
        """True if version is compatible with all the predicates in self.
        The parameter version must be acceptable to the StrictVersion
        constructor.  It may be either a string or StrictVersion.
        """
        for cond, ver in self.pred:
            if not compmap[cond](version, ver):
                return False
        return True


_provision_rx = None


def split_provision(value):
    """Return the name and optional version number of a provision.

    The version number, if given, will be returned as a `StrictVersion`
    instance, otherwise it will be `None`.

    >>> split_provision('mypkg')
    ('mypkg', None)
    >>> split_provision(' mypkg( 1.2 ) ')
    ('mypkg', StrictVersion ('1.2'))
    """
    global _provision_rx
    if _provision_rx is None:
        _provision_rx = re.compile(
            r"([a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)(?:\s*\(\s*([^)\s]+)\s*\))?$", re.ASCII
        )
    value = value.strip()
    m = _provision_rx.match(value)
    if not m:
        raise ValueError("illegal provides specification: %r" % value)
    ver = m.group(2) or None
    if ver:
        with version.suppress_known_deprecation():
            ver = version.StrictVersion(ver)
    return m.group(1), ver
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_entry_points.py0000644000175100001730000000427314467657412021147 0ustar00runnerdockerimport functools
import operator
import itertools

from .errors import OptionError
from .extern.jaraco.text import yield_lines
from .extern.jaraco.functools import pass_none
from ._importlib import metadata
from ._itertools import ensure_unique
from .extern.more_itertools import consume


def ensure_valid(ep):
    """
    Exercise one of the dynamic properties to trigger
    the pattern match.
    """
    try:
        ep.extras
    except AttributeError as ex:
        msg = (
            f"Problems to parse {ep}.\nPlease ensure entry-point follows the spec: "
            "https://packaging.python.org/en/latest/specifications/entry-points/"
        )
        raise OptionError(msg) from ex


def load_group(value, group):
    """
    Given a value of an entry point or series of entry points,
    return each as an EntryPoint.
    """
    # normalize to a single sequence of lines
    lines = yield_lines(value)
    text = f'[{group}]\n' + '\n'.join(lines)
    return metadata.EntryPoints._from_text(text)


def by_group_and_name(ep):
    return ep.group, ep.name


def validate(eps: metadata.EntryPoints):
    """
    Ensure entry points are unique by group and name and validate each.
    """
    consume(map(ensure_valid, ensure_unique(eps, key=by_group_and_name)))
    return eps


@functools.singledispatch
def load(eps):
    """
    Given a Distribution.entry_points, produce EntryPoints.
    """
    groups = itertools.chain.from_iterable(
        load_group(value, group) for group, value in eps.items()
    )
    return validate(metadata.EntryPoints(groups))


@load.register(str)
def _(eps):
    r"""
    >>> ep, = load('[console_scripts]\nfoo=bar')
    >>> ep.group
    'console_scripts'
    >>> ep.name
    'foo'
    >>> ep.value
    'bar'
    """
    return validate(metadata.EntryPoints(metadata.EntryPoints._from_text(eps)))


load.register(type(None), lambda x: x)


@pass_none
def render(eps: metadata.EntryPoints):
    by_group = operator.attrgetter('group')
    groups = itertools.groupby(sorted(eps, key=by_group), by_group)

    return '\n'.join(f'[{group}]\n{render_items(items)}\n' for group, items in groups)


def render_items(eps):
    return '\n'.join(f'{ep.name} = {ep.value}' for ep in sorted(eps))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_imp.py0000644000175100001730000000460114467657412017172 0ustar00runnerdocker"""
Re-implementation of find_module and get_frozen_object
from the deprecated imp module.
"""

import os
import importlib.util
import importlib.machinery

from importlib.util import module_from_spec


PY_SOURCE = 1
PY_COMPILED = 2
C_EXTENSION = 3
C_BUILTIN = 6
PY_FROZEN = 7


def find_spec(module, paths):
    finder = (
        importlib.machinery.PathFinder().find_spec
        if isinstance(paths, list)
        else importlib.util.find_spec
    )
    return finder(module, paths)


def find_module(module, paths=None):
    """Just like 'imp.find_module()', but with package support"""
    spec = find_spec(module, paths)
    if spec is None:
        raise ImportError("Can't find %s" % module)
    if not spec.has_location and hasattr(spec, 'submodule_search_locations'):
        spec = importlib.util.spec_from_loader('__init__.py', spec.loader)

    kind = -1
    file = None
    static = isinstance(spec.loader, type)
    if (
        spec.origin == 'frozen'
        or static
        and issubclass(spec.loader, importlib.machinery.FrozenImporter)
    ):
        kind = PY_FROZEN
        path = None  # imp compabilty
        suffix = mode = ''  # imp compatibility
    elif (
        spec.origin == 'built-in'
        or static
        and issubclass(spec.loader, importlib.machinery.BuiltinImporter)
    ):
        kind = C_BUILTIN
        path = None  # imp compabilty
        suffix = mode = ''  # imp compatibility
    elif spec.has_location:
        path = spec.origin
        suffix = os.path.splitext(path)[1]
        mode = 'r' if suffix in importlib.machinery.SOURCE_SUFFIXES else 'rb'

        if suffix in importlib.machinery.SOURCE_SUFFIXES:
            kind = PY_SOURCE
        elif suffix in importlib.machinery.BYTECODE_SUFFIXES:
            kind = PY_COMPILED
        elif suffix in importlib.machinery.EXTENSION_SUFFIXES:
            kind = C_EXTENSION

        if kind in {PY_SOURCE, PY_COMPILED}:
            file = open(path, mode)
    else:
        path = None
        suffix = mode = ''

    return file, path, (suffix, mode, kind)


def get_frozen_object(module, paths=None):
    spec = find_spec(module, paths)
    if not spec:
        raise ImportError("Can't find %s" % module)
    return spec.loader.get_code(module)


def get_module(module, paths, info):
    spec = find_spec(module, paths)
    if not spec:
        raise ImportError("Can't find %s" % module)
    return module_from_spec(spec)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_importlib.py0000644000175100001730000000267414467657412020416 0ustar00runnerdockerimport sys


def disable_importlib_metadata_finder(metadata):
    """
    Ensure importlib_metadata doesn't provide older, incompatible
    Distributions.

    Workaround for #3102.
    """
    try:
        import importlib_metadata
    except ImportError:
        return
    except AttributeError:
        from .warnings import SetuptoolsWarning

        SetuptoolsWarning.emit(
            "Incompatibility problem.",
            """
            `importlib-metadata` version is incompatible with `setuptools`.
            This problem is likely to be solved by installing an updated version of
            `importlib-metadata`.
            """,
            see_url="https://github.com/python/importlib_metadata/issues/396",
        )  # Ensure a descriptive message is shown.
        raise  # This exception can be suppressed by _distutils_hack

    if importlib_metadata is metadata:
        return
    to_remove = [
        ob
        for ob in sys.meta_path
        if isinstance(ob, importlib_metadata.MetadataPathFinder)
    ]
    for item in to_remove:
        sys.meta_path.remove(item)


if sys.version_info < (3, 10):
    from setuptools.extern import importlib_metadata as metadata

    disable_importlib_metadata_finder(metadata)
else:
    import importlib.metadata as metadata  # noqa: F401


if sys.version_info < (3, 9):
    from setuptools.extern import importlib_resources as resources
else:
    import importlib.resources as resources  # noqa: F401
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_itertools.py0000644000175100001730000000124314467657412020430 0ustar00runnerdockerfrom setuptools.extern.more_itertools import consume  # noqa: F401


# copied from jaraco.itertools 6.1
def ensure_unique(iterable, key=lambda x: x):
    """
    Wrap an iterable to raise a ValueError if non-unique values are encountered.

    >>> list(ensure_unique('abc'))
    ['a', 'b', 'c']
    >>> consume(ensure_unique('abca'))
    Traceback (most recent call last):
    ...
    ValueError: Duplicate element 'a' encountered.
    """
    seen = set()
    seen_add = seen.add
    for element in iterable:
        k = key(element)
        if k in seen:
            raise ValueError(f"Duplicate element {element!r} encountered.")
        seen_add(k)
        yield element
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_normalization.py0000644000175100001730000000717214467657412021301 0ustar00runnerdocker"""
Helpers for normalization as expected in wheel/sdist/module file names
and core metadata
"""
import re
from pathlib import Path
from typing import Union

from .extern import packaging
from .warnings import SetuptoolsDeprecationWarning

_Path = Union[str, Path]

# https://packaging.python.org/en/latest/specifications/core-metadata/#name
_VALID_NAME = re.compile(r"^([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])$", re.I)
_UNSAFE_NAME_CHARS = re.compile(r"[^A-Z0-9.]+", re.I)


def safe_identifier(name: str) -> str:
    """Make a string safe to be used as Python identifier.
    >>> safe_identifier("12abc")
    '_12abc'
    >>> safe_identifier("__editable__.myns.pkg-78.9.3_local")
    '__editable___myns_pkg_78_9_3_local'
    """
    safe = re.sub(r'\W|^(?=\d)', '_', name)
    assert safe.isidentifier()
    return safe


def safe_name(component: str) -> str:
    """Escape a component used as a project name according to Core Metadata.
    >>> safe_name("hello world")
    'hello-world'
    >>> safe_name("hello?world")
    'hello-world'
    """
    # See pkg_resources.safe_name
    return _UNSAFE_NAME_CHARS.sub("-", component)


def safe_version(version: str) -> str:
    """Convert an arbitrary string into a valid version string.
    >>> safe_version("1988 12 25")
    '1988.12.25'
    >>> safe_version("v0.2.1")
    '0.2.1'
    >>> safe_version("v0.2?beta")
    '0.2b0'
    >>> safe_version("v0.2 beta")
    '0.2b0'
    >>> safe_version("ubuntu lts")
    Traceback (most recent call last):
    ...
    setuptools.extern.packaging.version.InvalidVersion: Invalid version: 'ubuntu.lts'
    """
    v = version.replace(' ', '.')
    try:
        return str(packaging.version.Version(v))
    except packaging.version.InvalidVersion:
        attempt = _UNSAFE_NAME_CHARS.sub("-", v)
        return str(packaging.version.Version(attempt))


def best_effort_version(version: str) -> str:
    """Convert an arbitrary string into a version-like string.
    >>> best_effort_version("v0.2 beta")
    '0.2b0'

    >>> import warnings
    >>> warnings.simplefilter("ignore", category=SetuptoolsDeprecationWarning)
    >>> best_effort_version("ubuntu lts")
    'ubuntu.lts'
    """
    # See pkg_resources.safe_version
    try:
        return safe_version(version)
    except packaging.version.InvalidVersion:
        SetuptoolsDeprecationWarning.emit(
            f"Invalid version: {version!r}.",
            f"""
            Version {version!r} is not valid according to PEP 440.

            Please make sure to specify a valid version for your package.
            Also note that future releases of setuptools may halt the build process
            if an invalid version is given.
            """,
            see_url="https://peps.python.org/pep-0440/",
            due_date=(2023, 9, 26),  # See setuptools/dist _validate_version
        )
        v = version.replace(' ', '.')
        return safe_name(v)


def filename_component(value: str) -> str:
    """Normalize each component of a filename (e.g. distribution/version part of wheel)
    Note: ``value`` needs to be already normalized.
    >>> filename_component("my-pkg")
    'my_pkg'
    """
    return value.replace("-", "_").strip("_")


def safer_name(value: str) -> str:
    """Like ``safe_name`` but can be used as filename component for wheel"""
    # See bdist_wheel.safer_name
    return filename_component(safe_name(value))


def safer_best_effort_version(value: str) -> str:
    """Like ``best_effort_version`` but can be used as filename component for wheel"""
    # See bdist_wheel.safer_verion
    # TODO: Replace with only safe_version in the future (no need for best effort)
    return filename_component(best_effort_version(value))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_path.py0000644000175100001730000000204014467657412017334 0ustar00runnerdockerimport os
import sys
from typing import Union

_Path = Union[str, os.PathLike]


def ensure_directory(path):
    """Ensure that the parent directory of `path` exists"""
    dirname = os.path.dirname(path)
    os.makedirs(dirname, exist_ok=True)


def same_path(p1: _Path, p2: _Path) -> bool:
    """Differs from os.path.samefile because it does not require paths to exist.
    Purely string based (no comparison between i-nodes).
    >>> same_path("a/b", "./a/b")
    True
    >>> same_path("a/b", "a/./b")
    True
    >>> same_path("a/b", "././a/b")
    True
    >>> same_path("a/b", "./a/b/c/..")
    True
    >>> same_path("a/b", "../a/b/c")
    False
    >>> same_path("a", "a/b")
    False
    """
    return normpath(p1) == normpath(p2)


def normpath(filename: _Path) -> str:
    """Normalize a file/dir name for comparison purposes."""
    # See pkg_resources.normalize_path for notes about cygwin
    file = os.path.abspath(filename) if sys.platform == 'cygwin' else filename
    return os.path.normcase(os.path.realpath(os.path.normpath(file)))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_reqs.py0000644000175100001730000000156214467657412017362 0ustar00runnerdockerfrom typing import Callable, Iterable, Iterator, TypeVar, Union, overload

import setuptools.extern.jaraco.text as text
from setuptools.extern.packaging.requirements import Requirement

_T = TypeVar("_T")
_StrOrIter = Union[str, Iterable[str]]


def parse_strings(strs: _StrOrIter) -> Iterator[str]:
    """
    Yield requirement strings for each specification in `strs`.

    `strs` must be a string, or a (possibly-nested) iterable thereof.
    """
    return text.join_continuation(map(text.drop_comment, text.yield_lines(strs)))


@overload
def parse(strs: _StrOrIter) -> Iterator[Requirement]:
    ...


@overload
def parse(strs: _StrOrIter, parser: Callable[[str], _T]) -> Iterator[_T]:
    ...


def parse(strs, parser=Requirement):
    """
    Replacement for ``pkg_resources.parse_requirements`` that uses ``packaging``.
    """
    return map(parser, parse_strings(strs))
././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1692360483.52755
setuptools-68.1.2/setuptools/_vendor/0000755000175100001730000000000014467657444017334 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/__init__.py0000644000175100001730000000000014467657412021426 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1692360483.52755
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/0000755000175100001730000000000014467657444023175 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/__init__.py0000644000175100001730000006360214467657412025310 0ustar00runnerdockerimport os
import re
import abc
import csv
import sys
from .. import zipp
import email
import pathlib
import operator
import textwrap
import warnings
import functools
import itertools
import posixpath
import collections

from . import _adapters, _meta, _py39compat
from ._collections import FreezableDefaultDict, Pair
from ._compat import (
    NullFinder,
    install,
    pypy_partial,
)
from ._functools import method_cache, pass_none
from ._itertools import always_iterable, unique_everseen
from ._meta import PackageMetadata, SimplePath

from contextlib import suppress
from importlib import import_module
from importlib.abc import MetaPathFinder
from itertools import starmap
from typing import List, Mapping, Optional


__all__ = [
    'Distribution',
    'DistributionFinder',
    'PackageMetadata',
    'PackageNotFoundError',
    'distribution',
    'distributions',
    'entry_points',
    'files',
    'metadata',
    'packages_distributions',
    'requires',
    'version',
]


class PackageNotFoundError(ModuleNotFoundError):
    """The package was not found."""

    def __str__(self):
        return f"No package metadata was found for {self.name}"

    @property
    def name(self):
        (name,) = self.args
        return name


class Sectioned:
    """
    A simple entry point config parser for performance

    >>> for item in Sectioned.read(Sectioned._sample):
    ...     print(item)
    Pair(name='sec1', value='# comments ignored')
    Pair(name='sec1', value='a = 1')
    Pair(name='sec1', value='b = 2')
    Pair(name='sec2', value='a = 2')

    >>> res = Sectioned.section_pairs(Sectioned._sample)
    >>> item = next(res)
    >>> item.name
    'sec1'
    >>> item.value
    Pair(name='a', value='1')
    >>> item = next(res)
    >>> item.value
    Pair(name='b', value='2')
    >>> item = next(res)
    >>> item.name
    'sec2'
    >>> item.value
    Pair(name='a', value='2')
    >>> list(res)
    []
    """

    _sample = textwrap.dedent(
        """
        [sec1]
        # comments ignored
        a = 1
        b = 2

        [sec2]
        a = 2
        """
    ).lstrip()

    @classmethod
    def section_pairs(cls, text):
        return (
            section._replace(value=Pair.parse(section.value))
            for section in cls.read(text, filter_=cls.valid)
            if section.name is not None
        )

    @staticmethod
    def read(text, filter_=None):
        lines = filter(filter_, map(str.strip, text.splitlines()))
        name = None
        for value in lines:
            section_match = value.startswith('[') and value.endswith(']')
            if section_match:
                name = value.strip('[]')
                continue
            yield Pair(name, value)

    @staticmethod
    def valid(line):
        return line and not line.startswith('#')


class DeprecatedTuple:
    """
    Provide subscript item access for backward compatibility.

    >>> recwarn = getfixture('recwarn')
    >>> ep = EntryPoint(name='name', value='value', group='group')
    >>> ep[:]
    ('name', 'value', 'group')
    >>> ep[0]
    'name'
    >>> len(recwarn)
    1
    """

    # Do not remove prior to 2023-05-01 or Python 3.13
    _warn = functools.partial(
        warnings.warn,
        "EntryPoint tuple interface is deprecated. Access members by name.",
        DeprecationWarning,
        stacklevel=pypy_partial(2),
    )

    def __getitem__(self, item):
        self._warn()
        return self._key()[item]


class EntryPoint(DeprecatedTuple):
    """An entry point as defined by Python packaging conventions.

    See `the packaging docs on entry points
    `_
    for more information.

    >>> ep = EntryPoint(
    ...     name=None, group=None, value='package.module:attr [extra1, extra2]')
    >>> ep.module
    'package.module'
    >>> ep.attr
    'attr'
    >>> ep.extras
    ['extra1', 'extra2']
    """

    pattern = re.compile(
        r'(?P[\w.]+)\s*'
        r'(:\s*(?P[\w.]+)\s*)?'
        r'((?P\[.*\])\s*)?$'
    )
    """
    A regular expression describing the syntax for an entry point,
    which might look like:

        - module
        - package.module
        - package.module:attribute
        - package.module:object.attribute
        - package.module:attr [extra1, extra2]

    Other combinations are possible as well.

    The expression is lenient about whitespace around the ':',
    following the attr, and following any extras.
    """

    name: str
    value: str
    group: str

    dist: Optional['Distribution'] = None

    def __init__(self, name, value, group):
        vars(self).update(name=name, value=value, group=group)

    def load(self):
        """Load the entry point from its definition. If only a module
        is indicated by the value, return that module. Otherwise,
        return the named object.
        """
        match = self.pattern.match(self.value)
        module = import_module(match.group('module'))
        attrs = filter(None, (match.group('attr') or '').split('.'))
        return functools.reduce(getattr, attrs, module)

    @property
    def module(self):
        match = self.pattern.match(self.value)
        return match.group('module')

    @property
    def attr(self):
        match = self.pattern.match(self.value)
        return match.group('attr')

    @property
    def extras(self):
        match = self.pattern.match(self.value)
        return re.findall(r'\w+', match.group('extras') or '')

    def _for(self, dist):
        vars(self).update(dist=dist)
        return self

    def matches(self, **params):
        """
        EntryPoint matches the given parameters.

        >>> ep = EntryPoint(group='foo', name='bar', value='bing:bong [extra1, extra2]')
        >>> ep.matches(group='foo')
        True
        >>> ep.matches(name='bar', value='bing:bong [extra1, extra2]')
        True
        >>> ep.matches(group='foo', name='other')
        False
        >>> ep.matches()
        True
        >>> ep.matches(extras=['extra1', 'extra2'])
        True
        >>> ep.matches(module='bing')
        True
        >>> ep.matches(attr='bong')
        True
        """
        attrs = (getattr(self, param) for param in params)
        return all(map(operator.eq, params.values(), attrs))

    def _key(self):
        return self.name, self.value, self.group

    def __lt__(self, other):
        return self._key() < other._key()

    def __eq__(self, other):
        return self._key() == other._key()

    def __setattr__(self, name, value):
        raise AttributeError("EntryPoint objects are immutable.")

    def __repr__(self):
        return (
            f'EntryPoint(name={self.name!r}, value={self.value!r}, '
            f'group={self.group!r})'
        )

    def __hash__(self):
        return hash(self._key())


class EntryPoints(tuple):
    """
    An immutable collection of selectable EntryPoint objects.
    """

    __slots__ = ()

    def __getitem__(self, name):  # -> EntryPoint:
        """
        Get the EntryPoint in self matching name.
        """
        try:
            return next(iter(self.select(name=name)))
        except StopIteration:
            raise KeyError(name)

    def select(self, **params):
        """
        Select entry points from self that match the
        given parameters (typically group and/or name).
        """
        return EntryPoints(ep for ep in self if _py39compat.ep_matches(ep, **params))

    @property
    def names(self):
        """
        Return the set of all names of all entry points.
        """
        return {ep.name for ep in self}

    @property
    def groups(self):
        """
        Return the set of all groups of all entry points.
        """
        return {ep.group for ep in self}

    @classmethod
    def _from_text_for(cls, text, dist):
        return cls(ep._for(dist) for ep in cls._from_text(text))

    @staticmethod
    def _from_text(text):
        return (
            EntryPoint(name=item.value.name, value=item.value.value, group=item.name)
            for item in Sectioned.section_pairs(text or '')
        )


class PackagePath(pathlib.PurePosixPath):
    """A reference to a path in a package"""

    def read_text(self, encoding='utf-8'):
        with self.locate().open(encoding=encoding) as stream:
            return stream.read()

    def read_binary(self):
        with self.locate().open('rb') as stream:
            return stream.read()

    def locate(self):
        """Return a path-like object for this path"""
        return self.dist.locate_file(self)


class FileHash:
    def __init__(self, spec):
        self.mode, _, self.value = spec.partition('=')

    def __repr__(self):
        return f''


class Distribution(metaclass=abc.ABCMeta):
    """A Python distribution package."""

    @abc.abstractmethod
    def read_text(self, filename):
        """Attempt to load metadata file given by the name.

        :param filename: The name of the file in the distribution info.
        :return: The text if found, otherwise None.
        """

    @abc.abstractmethod
    def locate_file(self, path):
        """
        Given a path to a file in this distribution, return a path
        to it.
        """

    @classmethod
    def from_name(cls, name: str):
        """Return the Distribution for the given package name.

        :param name: The name of the distribution package to search for.
        :return: The Distribution instance (or subclass thereof) for the named
            package, if found.
        :raises PackageNotFoundError: When the named package's distribution
            metadata cannot be found.
        :raises ValueError: When an invalid value is supplied for name.
        """
        if not name:
            raise ValueError("A distribution name is required.")
        try:
            return next(cls.discover(name=name))
        except StopIteration:
            raise PackageNotFoundError(name)

    @classmethod
    def discover(cls, **kwargs):
        """Return an iterable of Distribution objects for all packages.

        Pass a ``context`` or pass keyword arguments for constructing
        a context.

        :context: A ``DistributionFinder.Context`` object.
        :return: Iterable of Distribution objects for all packages.
        """
        context = kwargs.pop('context', None)
        if context and kwargs:
            raise ValueError("cannot accept context and kwargs")
        context = context or DistributionFinder.Context(**kwargs)
        return itertools.chain.from_iterable(
            resolver(context) for resolver in cls._discover_resolvers()
        )

    @staticmethod
    def at(path):
        """Return a Distribution for the indicated metadata path

        :param path: a string or path-like object
        :return: a concrete Distribution instance for the path
        """
        return PathDistribution(pathlib.Path(path))

    @staticmethod
    def _discover_resolvers():
        """Search the meta_path for resolvers."""
        declared = (
            getattr(finder, 'find_distributions', None) for finder in sys.meta_path
        )
        return filter(None, declared)

    @property
    def metadata(self) -> _meta.PackageMetadata:
        """Return the parsed metadata for this Distribution.

        The returned object will have keys that name the various bits of
        metadata.  See PEP 566 for details.
        """
        text = (
            self.read_text('METADATA')
            or self.read_text('PKG-INFO')
            # This last clause is here to support old egg-info files.  Its
            # effect is to just end up using the PathDistribution's self._path
            # (which points to the egg-info file) attribute unchanged.
            or self.read_text('')
        )
        return _adapters.Message(email.message_from_string(text))

    @property
    def name(self):
        """Return the 'Name' metadata for the distribution package."""
        return self.metadata['Name']

    @property
    def _normalized_name(self):
        """Return a normalized version of the name."""
        return Prepared.normalize(self.name)

    @property
    def version(self):
        """Return the 'Version' metadata for the distribution package."""
        return self.metadata['Version']

    @property
    def entry_points(self):
        return EntryPoints._from_text_for(self.read_text('entry_points.txt'), self)

    @property
    def files(self):
        """Files in this distribution.

        :return: List of PackagePath for this distribution or None

        Result is `None` if the metadata file that enumerates files
        (i.e. RECORD for dist-info or SOURCES.txt for egg-info) is
        missing.
        Result may be empty if the metadata exists but is empty.
        """

        def make_file(name, hash=None, size_str=None):
            result = PackagePath(name)
            result.hash = FileHash(hash) if hash else None
            result.size = int(size_str) if size_str else None
            result.dist = self
            return result

        @pass_none
        def make_files(lines):
            return list(starmap(make_file, csv.reader(lines)))

        return make_files(self._read_files_distinfo() or self._read_files_egginfo())

    def _read_files_distinfo(self):
        """
        Read the lines of RECORD
        """
        text = self.read_text('RECORD')
        return text and text.splitlines()

    def _read_files_egginfo(self):
        """
        SOURCES.txt might contain literal commas, so wrap each line
        in quotes.
        """
        text = self.read_text('SOURCES.txt')
        return text and map('"{}"'.format, text.splitlines())

    @property
    def requires(self):
        """Generated requirements specified for this Distribution"""
        reqs = self._read_dist_info_reqs() or self._read_egg_info_reqs()
        return reqs and list(reqs)

    def _read_dist_info_reqs(self):
        return self.metadata.get_all('Requires-Dist')

    def _read_egg_info_reqs(self):
        source = self.read_text('requires.txt')
        return pass_none(self._deps_from_requires_text)(source)

    @classmethod
    def _deps_from_requires_text(cls, source):
        return cls._convert_egg_info_reqs_to_simple_reqs(Sectioned.read(source))

    @staticmethod
    def _convert_egg_info_reqs_to_simple_reqs(sections):
        """
        Historically, setuptools would solicit and store 'extra'
        requirements, including those with environment markers,
        in separate sections. More modern tools expect each
        dependency to be defined separately, with any relevant
        extras and environment markers attached directly to that
        requirement. This method converts the former to the
        latter. See _test_deps_from_requires_text for an example.
        """

        def make_condition(name):
            return name and f'extra == "{name}"'

        def quoted_marker(section):
            section = section or ''
            extra, sep, markers = section.partition(':')
            if extra and markers:
                markers = f'({markers})'
            conditions = list(filter(None, [markers, make_condition(extra)]))
            return '; ' + ' and '.join(conditions) if conditions else ''

        def url_req_space(req):
            """
            PEP 508 requires a space between the url_spec and the quoted_marker.
            Ref python/importlib_metadata#357.
            """
            # '@' is uniquely indicative of a url_req.
            return ' ' * ('@' in req)

        for section in sections:
            space = url_req_space(section.value)
            yield section.value + space + quoted_marker(section.name)


class DistributionFinder(MetaPathFinder):
    """
    A MetaPathFinder capable of discovering installed distributions.
    """

    class Context:
        """
        Keyword arguments presented by the caller to
        ``distributions()`` or ``Distribution.discover()``
        to narrow the scope of a search for distributions
        in all DistributionFinders.

        Each DistributionFinder may expect any parameters
        and should attempt to honor the canonical
        parameters defined below when appropriate.
        """

        name = None
        """
        Specific name for which a distribution finder should match.
        A name of ``None`` matches all distributions.
        """

        def __init__(self, **kwargs):
            vars(self).update(kwargs)

        @property
        def path(self):
            """
            The sequence of directory path that a distribution finder
            should search.

            Typically refers to Python installed package paths such as
            "site-packages" directories and defaults to ``sys.path``.
            """
            return vars(self).get('path', sys.path)

    @abc.abstractmethod
    def find_distributions(self, context=Context()):
        """
        Find distributions.

        Return an iterable of all Distribution instances capable of
        loading the metadata for packages matching the ``context``,
        a DistributionFinder.Context instance.
        """


class FastPath:
    """
    Micro-optimized class for searching a path for
    children.

    >>> FastPath('').children()
    ['...']
    """

    @functools.lru_cache()  # type: ignore
    def __new__(cls, root):
        return super().__new__(cls)

    def __init__(self, root):
        self.root = root

    def joinpath(self, child):
        return pathlib.Path(self.root, child)

    def children(self):
        with suppress(Exception):
            return os.listdir(self.root or '.')
        with suppress(Exception):
            return self.zip_children()
        return []

    def zip_children(self):
        zip_path = zipp.Path(self.root)
        names = zip_path.root.namelist()
        self.joinpath = zip_path.joinpath

        return dict.fromkeys(child.split(posixpath.sep, 1)[0] for child in names)

    def search(self, name):
        return self.lookup(self.mtime).search(name)

    @property
    def mtime(self):
        with suppress(OSError):
            return os.stat(self.root).st_mtime
        self.lookup.cache_clear()

    @method_cache
    def lookup(self, mtime):
        return Lookup(self)


class Lookup:
    def __init__(self, path: FastPath):
        base = os.path.basename(path.root).lower()
        base_is_egg = base.endswith(".egg")
        self.infos = FreezableDefaultDict(list)
        self.eggs = FreezableDefaultDict(list)

        for child in path.children():
            low = child.lower()
            if low.endswith((".dist-info", ".egg-info")):
                # rpartition is faster than splitext and suitable for this purpose.
                name = low.rpartition(".")[0].partition("-")[0]
                normalized = Prepared.normalize(name)
                self.infos[normalized].append(path.joinpath(child))
            elif base_is_egg and low == "egg-info":
                name = base.rpartition(".")[0].partition("-")[0]
                legacy_normalized = Prepared.legacy_normalize(name)
                self.eggs[legacy_normalized].append(path.joinpath(child))

        self.infos.freeze()
        self.eggs.freeze()

    def search(self, prepared):
        infos = (
            self.infos[prepared.normalized]
            if prepared
            else itertools.chain.from_iterable(self.infos.values())
        )
        eggs = (
            self.eggs[prepared.legacy_normalized]
            if prepared
            else itertools.chain.from_iterable(self.eggs.values())
        )
        return itertools.chain(infos, eggs)


class Prepared:
    """
    A prepared search for metadata on a possibly-named package.
    """

    normalized = None
    legacy_normalized = None

    def __init__(self, name):
        self.name = name
        if name is None:
            return
        self.normalized = self.normalize(name)
        self.legacy_normalized = self.legacy_normalize(name)

    @staticmethod
    def normalize(name):
        """
        PEP 503 normalization plus dashes as underscores.
        """
        return re.sub(r"[-_.]+", "-", name).lower().replace('-', '_')

    @staticmethod
    def legacy_normalize(name):
        """
        Normalize the package name as found in the convention in
        older packaging tools versions and specs.
        """
        return name.lower().replace('-', '_')

    def __bool__(self):
        return bool(self.name)


@install
class MetadataPathFinder(NullFinder, DistributionFinder):
    """A degenerate finder for distribution packages on the file system.

    This finder supplies only a find_distributions() method for versions
    of Python that do not have a PathFinder find_distributions().
    """

    def find_distributions(self, context=DistributionFinder.Context()):
        """
        Find distributions.

        Return an iterable of all Distribution instances capable of
        loading the metadata for packages matching ``context.name``
        (or all names if ``None`` indicated) along the paths in the list
        of directories ``context.path``.
        """
        found = self._search_paths(context.name, context.path)
        return map(PathDistribution, found)

    @classmethod
    def _search_paths(cls, name, paths):
        """Find metadata directories in paths heuristically."""
        prepared = Prepared(name)
        return itertools.chain.from_iterable(
            path.search(prepared) for path in map(FastPath, paths)
        )

    def invalidate_caches(cls):
        FastPath.__new__.cache_clear()


class PathDistribution(Distribution):
    def __init__(self, path: SimplePath):
        """Construct a distribution.

        :param path: SimplePath indicating the metadata directory.
        """
        self._path = path

    def read_text(self, filename):
        with suppress(
            FileNotFoundError,
            IsADirectoryError,
            KeyError,
            NotADirectoryError,
            PermissionError,
        ):
            return self._path.joinpath(filename).read_text(encoding='utf-8')

    read_text.__doc__ = Distribution.read_text.__doc__

    def locate_file(self, path):
        return self._path.parent / path

    @property
    def _normalized_name(self):
        """
        Performance optimization: where possible, resolve the
        normalized name from the file system path.
        """
        stem = os.path.basename(str(self._path))
        return (
            pass_none(Prepared.normalize)(self._name_from_stem(stem))
            or super()._normalized_name
        )

    @staticmethod
    def _name_from_stem(stem):
        """
        >>> PathDistribution._name_from_stem('foo-3.0.egg-info')
        'foo'
        >>> PathDistribution._name_from_stem('CherryPy-3.0.dist-info')
        'CherryPy'
        >>> PathDistribution._name_from_stem('face.egg-info')
        'face'
        >>> PathDistribution._name_from_stem('foo.bar')
        """
        filename, ext = os.path.splitext(stem)
        if ext not in ('.dist-info', '.egg-info'):
            return
        name, sep, rest = filename.partition('-')
        return name


def distribution(distribution_name):
    """Get the ``Distribution`` instance for the named package.

    :param distribution_name: The name of the distribution package as a string.
    :return: A ``Distribution`` instance (or subclass thereof).
    """
    return Distribution.from_name(distribution_name)


def distributions(**kwargs):
    """Get all ``Distribution`` instances in the current environment.

    :return: An iterable of ``Distribution`` instances.
    """
    return Distribution.discover(**kwargs)


def metadata(distribution_name) -> _meta.PackageMetadata:
    """Get the metadata for the named package.

    :param distribution_name: The name of the distribution package to query.
    :return: A PackageMetadata containing the parsed metadata.
    """
    return Distribution.from_name(distribution_name).metadata


def version(distribution_name):
    """Get the version string for the named package.

    :param distribution_name: The name of the distribution package to query.
    :return: The version string for the package as defined in the package's
        "Version" metadata key.
    """
    return distribution(distribution_name).version


_unique = functools.partial(
    unique_everseen,
    key=_py39compat.normalized_name,
)
"""
Wrapper for ``distributions`` to return unique distributions by name.
"""


def entry_points(**params) -> EntryPoints:
    """Return EntryPoint objects for all installed packages.

    Pass selection parameters (group or name) to filter the
    result to entry points matching those properties (see
    EntryPoints.select()).

    :return: EntryPoints for all installed packages.
    """
    eps = itertools.chain.from_iterable(
        dist.entry_points for dist in _unique(distributions())
    )
    return EntryPoints(eps).select(**params)


def files(distribution_name):
    """Return a list of files for the named package.

    :param distribution_name: The name of the distribution package to query.
    :return: List of files composing the distribution.
    """
    return distribution(distribution_name).files


def requires(distribution_name):
    """
    Return a list of requirements for the named package.

    :return: An iterator of requirements, suitable for
        packaging.requirement.Requirement.
    """
    return distribution(distribution_name).requires


def packages_distributions() -> Mapping[str, List[str]]:
    """
    Return a mapping of top-level packages to their
    distributions.

    >>> import collections.abc
    >>> pkgs = packages_distributions()
    >>> all(isinstance(dist, collections.abc.Sequence) for dist in pkgs.values())
    True
    """
    pkg_to_dist = collections.defaultdict(list)
    for dist in distributions():
        for pkg in _top_level_declared(dist) or _top_level_inferred(dist):
            pkg_to_dist[pkg].append(dist.metadata['Name'])
    return dict(pkg_to_dist)


def _top_level_declared(dist):
    return (dist.read_text('top_level.txt') or '').split()


def _top_level_inferred(dist):
    return {
        f.parts[0] if len(f.parts) > 1 else f.with_suffix('').name
        for f in always_iterable(dist.files)
        if f.suffix == ".py"
    }
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_adapters.py0000644000175100001730000000462614467657412025514 0ustar00runnerdockerimport functools
import warnings
import re
import textwrap
import email.message

from ._text import FoldedCase
from ._compat import pypy_partial


# Do not remove prior to 2024-01-01 or Python 3.14
_warn = functools.partial(
    warnings.warn,
    "Implicit None on return values is deprecated and will raise KeyErrors.",
    DeprecationWarning,
    stacklevel=pypy_partial(2),
)


class Message(email.message.Message):
    multiple_use_keys = set(
        map(
            FoldedCase,
            [
                'Classifier',
                'Obsoletes-Dist',
                'Platform',
                'Project-URL',
                'Provides-Dist',
                'Provides-Extra',
                'Requires-Dist',
                'Requires-External',
                'Supported-Platform',
                'Dynamic',
            ],
        )
    )
    """
    Keys that may be indicated multiple times per PEP 566.
    """

    def __new__(cls, orig: email.message.Message):
        res = super().__new__(cls)
        vars(res).update(vars(orig))
        return res

    def __init__(self, *args, **kwargs):
        self._headers = self._repair_headers()

    # suppress spurious error from mypy
    def __iter__(self):
        return super().__iter__()

    def __getitem__(self, item):
        """
        Warn users that a ``KeyError`` can be expected when a
        mising key is supplied. Ref python/importlib_metadata#371.
        """
        res = super().__getitem__(item)
        if res is None:
            _warn()
        return res

    def _repair_headers(self):
        def redent(value):
            "Correct for RFC822 indentation"
            if not value or '\n' not in value:
                return value
            return textwrap.dedent(' ' * 8 + value)

        headers = [(key, redent(value)) for key, value in vars(self)['_headers']]
        if self._payload:
            headers.append(('Description', self.get_payload()))
        return headers

    @property
    def json(self):
        """
        Convert PackageMetadata to a JSON-compatible format
        per PEP 0566.
        """

        def transform(key):
            value = self.get_all(key) if key in self.multiple_use_keys else self[key]
            if key == 'Keywords':
                value = re.split(r'\s+', value)
            tk = key.lower().replace('-', '_')
            return tk, value

        return dict(map(transform, map(FoldedCase, self)))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_collections.py0000644000175100001730000000134714467657412026224 0ustar00runnerdockerimport collections


# from jaraco.collections 3.3
class FreezableDefaultDict(collections.defaultdict):
    """
    Often it is desirable to prevent the mutation of
    a default dict after its initial construction, such
    as to prevent mutation during iteration.

    >>> dd = FreezableDefaultDict(list)
    >>> dd[0].append('1')
    >>> dd.freeze()
    >>> dd[1]
    []
    >>> len(dd)
    1
    """

    def __missing__(self, key):
        return getattr(self, '_frozen', super().__missing__)(key)

    def freeze(self):
        self._frozen = lambda key: self.default_factory()


class Pair(collections.namedtuple('Pair', 'name value')):
    @classmethod
    def parse(cls, text):
        return cls(*map(str.strip, text.split("=", 1)))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_compat.py0000644000175100001730000000350314467657412025165 0ustar00runnerdockerimport sys
import platform


__all__ = ['install', 'NullFinder', 'Protocol']


try:
    from typing import Protocol
except ImportError:  # pragma: no cover
    # Python 3.7 compatibility
    from ..typing_extensions import Protocol  # type: ignore


def install(cls):
    """
    Class decorator for installation on sys.meta_path.

    Adds the backport DistributionFinder to sys.meta_path and
    attempts to disable the finder functionality of the stdlib
    DistributionFinder.
    """
    sys.meta_path.append(cls())
    disable_stdlib_finder()
    return cls


def disable_stdlib_finder():
    """
    Give the backport primacy for discovering path-based distributions
    by monkey-patching the stdlib O_O.

    See #91 for more background for rationale on this sketchy
    behavior.
    """

    def matches(finder):
        return getattr(
            finder, '__module__', None
        ) == '_frozen_importlib_external' and hasattr(finder, 'find_distributions')

    for finder in filter(matches, sys.meta_path):  # pragma: nocover
        del finder.find_distributions


class NullFinder:
    """
    A "Finder" (aka "MetaClassFinder") that never finds any modules,
    but may find distributions.
    """

    @staticmethod
    def find_spec(*args, **kwargs):
        return None

    # In Python 2, the import system requires finders
    # to have a find_module() method, but this usage
    # is deprecated in Python 3 in favor of find_spec().
    # For the purposes of this finder (i.e. being present
    # on sys.meta_path but having no other import
    # system functionality), the two methods are identical.
    find_module = find_spec


def pypy_partial(val):
    """
    Adjust for variable stacklevel on partial under PyPy.

    Workaround for #327.
    """
    is_pypy = platform.python_implementation() == 'PyPy'
    return val + is_pypy
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_functools.py0000644000175100001730000000551714467657412025725 0ustar00runnerdockerimport types
import functools


# from jaraco.functools 3.3
def method_cache(method, cache_wrapper=None):
    """
    Wrap lru_cache to support storing the cache data in the object instances.

    Abstracts the common paradigm where the method explicitly saves an
    underscore-prefixed protected property on first call and returns that
    subsequently.

    >>> class MyClass:
    ...     calls = 0
    ...
    ...     @method_cache
    ...     def method(self, value):
    ...         self.calls += 1
    ...         return value

    >>> a = MyClass()
    >>> a.method(3)
    3
    >>> for x in range(75):
    ...     res = a.method(x)
    >>> a.calls
    75

    Note that the apparent behavior will be exactly like that of lru_cache
    except that the cache is stored on each instance, so values in one
    instance will not flush values from another, and when an instance is
    deleted, so are the cached values for that instance.

    >>> b = MyClass()
    >>> for x in range(35):
    ...     res = b.method(x)
    >>> b.calls
    35
    >>> a.method(0)
    0
    >>> a.calls
    75

    Note that if method had been decorated with ``functools.lru_cache()``,
    a.calls would have been 76 (due to the cached value of 0 having been
    flushed by the 'b' instance).

    Clear the cache with ``.cache_clear()``

    >>> a.method.cache_clear()

    Same for a method that hasn't yet been called.

    >>> c = MyClass()
    >>> c.method.cache_clear()

    Another cache wrapper may be supplied:

    >>> cache = functools.lru_cache(maxsize=2)
    >>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache)
    >>> a = MyClass()
    >>> a.method2()
    3

    Caution - do not subsequently wrap the method with another decorator, such
    as ``@property``, which changes the semantics of the function.

    See also
    http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/
    for another implementation and additional justification.
    """
    cache_wrapper = cache_wrapper or functools.lru_cache()

    def wrapper(self, *args, **kwargs):
        # it's the first call, replace the method with a cached, bound method
        bound_method = types.MethodType(method, self)
        cached_method = cache_wrapper(bound_method)
        setattr(self, method.__name__, cached_method)
        return cached_method(*args, **kwargs)

    # Support cache clear even before cache has been created.
    wrapper.cache_clear = lambda: None

    return wrapper


# From jaraco.functools 3.3
def pass_none(func):
    """
    Wrap func so it's not called if its first param is None

    >>> print_text = pass_none(print)
    >>> print_text('text')
    text
    >>> print_text(None)
    """

    @functools.wraps(func)
    def wrapper(param, *args, **kwargs):
        if param is not None:
            return func(param, *args, **kwargs)

    return wrapper
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_itertools.py0000644000175100001730000000402414467657412025725 0ustar00runnerdockerfrom itertools import filterfalse


def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element


# copied from more_itertools 8.8
def always_iterable(obj, base_type=(str, bytes)):
    """If *obj* is iterable, return an iterator over its items::

        >>> obj = (1, 2, 3)
        >>> list(always_iterable(obj))
        [1, 2, 3]

    If *obj* is not iterable, return a one-item iterable containing *obj*::

        >>> obj = 1
        >>> list(always_iterable(obj))
        [1]

    If *obj* is ``None``, return an empty iterable:

        >>> obj = None
        >>> list(always_iterable(None))
        []

    By default, binary and text strings are not considered iterable::

        >>> obj = 'foo'
        >>> list(always_iterable(obj))
        ['foo']

    If *base_type* is set, objects for which ``isinstance(obj, base_type)``
    returns ``True`` won't be considered iterable.

        >>> obj = {'a': 1}
        >>> list(always_iterable(obj))  # Iterate over the dict's keys
        ['a']
        >>> list(always_iterable(obj, base_type=dict))  # Treat dicts as a unit
        [{'a': 1}]

    Set *base_type* to ``None`` to avoid any special handling and treat objects
    Python considers iterable as iterable:

        >>> obj = 'foo'
        >>> list(always_iterable(obj, base_type=None))
        ['f', 'o', 'o']
    """
    if obj is None:
        return iter(())

    if (base_type is not None) and isinstance(obj, base_type):
        return iter((obj,))

    try:
        return iter(obj)
    except TypeError:
        return iter((obj,))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_meta.py0000644000175100001730000000221514467657412024627 0ustar00runnerdockerfrom ._compat import Protocol
from typing import Any, Dict, Iterator, List, TypeVar, Union


_T = TypeVar("_T")


class PackageMetadata(Protocol):
    def __len__(self) -> int:
        ...  # pragma: no cover

    def __contains__(self, item: str) -> bool:
        ...  # pragma: no cover

    def __getitem__(self, key: str) -> str:
        ...  # pragma: no cover

    def __iter__(self) -> Iterator[str]:
        ...  # pragma: no cover

    def get_all(self, name: str, failobj: _T = ...) -> Union[List[Any], _T]:
        """
        Return all values associated with a possibly multi-valued key.
        """

    @property
    def json(self) -> Dict[str, Union[str, List[str]]]:
        """
        A JSON-compatible form of the metadata.
        """


class SimplePath(Protocol[_T]):
    """
    A minimal subset of pathlib.Path required by PathDistribution.
    """

    def joinpath(self) -> _T:
        ...  # pragma: no cover

    def __truediv__(self, other: Union[str, _T]) -> _T:
        ...  # pragma: no cover

    @property
    def parent(self) -> _T:
        ...  # pragma: no cover

    def read_text(self) -> str:
        ...  # pragma: no cover
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_py39compat.py0000644000175100001730000000211214467657412025705 0ustar00runnerdocker"""
Compatibility layer with Python 3.8/3.9
"""
from typing import TYPE_CHECKING, Any, Optional

if TYPE_CHECKING:  # pragma: no cover
    # Prevent circular imports on runtime.
    from . import Distribution, EntryPoint
else:
    Distribution = EntryPoint = Any


def normalized_name(dist: Distribution) -> Optional[str]:
    """
    Honor name normalization for distributions that don't provide ``_normalized_name``.
    """
    try:
        return dist._normalized_name
    except AttributeError:
        from . import Prepared  # -> delay to prevent circular imports.

        return Prepared.normalize(getattr(dist, "name", None) or dist.metadata['Name'])


def ep_matches(ep: EntryPoint, **params) -> bool:
    """
    Workaround for ``EntryPoint`` objects without the ``matches`` method.
    """
    try:
        return ep.matches(**params)
    except AttributeError:
        from . import EntryPoint  # -> delay to prevent circular imports.

        # Reconstruct the EntryPoint object to make sure it is compatible.
        return EntryPoint(ep.name, ep.value, ep.group).matches(**params)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata/_text.py0000644000175100001730000000416614467657412024674 0ustar00runnerdockerimport re

from ._functools import method_cache


# from jaraco.text 3.5
class FoldedCase(str):
    """
    A case insensitive string class; behaves just like str
    except compares equal when the only variation is case.

    >>> s = FoldedCase('hello world')

    >>> s == 'Hello World'
    True

    >>> 'Hello World' == s
    True

    >>> s != 'Hello World'
    False

    >>> s.index('O')
    4

    >>> s.split('O')
    ['hell', ' w', 'rld']

    >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta']))
    ['alpha', 'Beta', 'GAMMA']

    Sequence membership is straightforward.

    >>> "Hello World" in [s]
    True
    >>> s in ["Hello World"]
    True

    You may test for set inclusion, but candidate and elements
    must both be folded.

    >>> FoldedCase("Hello World") in {s}
    True
    >>> s in {FoldedCase("Hello World")}
    True

    String inclusion works as long as the FoldedCase object
    is on the right.

    >>> "hello" in FoldedCase("Hello World")
    True

    But not if the FoldedCase object is on the left:

    >>> FoldedCase('hello') in 'Hello World'
    False

    In that case, use in_:

    >>> FoldedCase('hello').in_('Hello World')
    True

    >>> FoldedCase('hello') > FoldedCase('Hello')
    False
    """

    def __lt__(self, other):
        return self.lower() < other.lower()

    def __gt__(self, other):
        return self.lower() > other.lower()

    def __eq__(self, other):
        return self.lower() == other.lower()

    def __ne__(self, other):
        return self.lower() != other.lower()

    def __hash__(self):
        return hash(self.lower())

    def __contains__(self, other):
        return super().lower().__contains__(other.lower())

    def in_(self, other):
        "Does self appear in other?"
        return self in FoldedCase(other)

    # cache lower since it's likely to be called frequently.
    @method_cache
    def lower(self):
        return super().lower()

    def index(self, sub):
        return self.lower().index(sub.lower())

    def split(self, splitter=' ', maxsplit=0):
        pattern = re.compile(re.escape(splitter), re.I)
        return pattern.split(self, maxsplit)
././@PaxHeader0000000000000000000000000000003200000000000010210 xustar0026 mtime=1692360483.52755
setuptools-68.1.2/setuptools/_vendor/importlib_metadata-6.0.0.dist-info/0000755000175100001730000000000014467657444025527 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_metadata-6.0.0.dist-info/top_level.txt0000644000175100001730000000002314467657412030247 0ustar00runnerdockerimportlib_metadata
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/0000755000175100001730000000000014467657444023427 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/__init__.py0000644000175100001730000000077214467657412025541 0ustar00runnerdocker"""Read resources contained within a package."""

from ._common import (
    as_file,
    files,
    Package,
)

from ._legacy import (
    contents,
    open_binary,
    read_binary,
    open_text,
    read_text,
    is_resource,
    path,
    Resource,
)

from .abc import ResourceReader


__all__ = [
    'Package',
    'Resource',
    'ResourceReader',
    'as_file',
    'contents',
    'files',
    'is_resource',
    'open_binary',
    'open_text',
    'path',
    'read_binary',
    'read_text',
]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/_adapters.py0000644000175100001730000001063014467657412025736 0ustar00runnerdockerfrom contextlib import suppress
from io import TextIOWrapper

from . import abc


class SpecLoaderAdapter:
    """
    Adapt a package spec to adapt the underlying loader.
    """

    def __init__(self, spec, adapter=lambda spec: spec.loader):
        self.spec = spec
        self.loader = adapter(spec)

    def __getattr__(self, name):
        return getattr(self.spec, name)


class TraversableResourcesLoader:
    """
    Adapt a loader to provide TraversableResources.
    """

    def __init__(self, spec):
        self.spec = spec

    def get_resource_reader(self, name):
        return CompatibilityFiles(self.spec)._native()


def _io_wrapper(file, mode='r', *args, **kwargs):
    if mode == 'r':
        return TextIOWrapper(file, *args, **kwargs)
    elif mode == 'rb':
        return file
    raise ValueError(
        "Invalid mode value '{}', only 'r' and 'rb' are supported".format(mode)
    )


class CompatibilityFiles:
    """
    Adapter for an existing or non-existent resource reader
    to provide a compatibility .files().
    """

    class SpecPath(abc.Traversable):
        """
        Path tied to a module spec.
        Can be read and exposes the resource reader children.
        """

        def __init__(self, spec, reader):
            self._spec = spec
            self._reader = reader

        def iterdir(self):
            if not self._reader:
                return iter(())
            return iter(
                CompatibilityFiles.ChildPath(self._reader, path)
                for path in self._reader.contents()
            )

        def is_file(self):
            return False

        is_dir = is_file

        def joinpath(self, other):
            if not self._reader:
                return CompatibilityFiles.OrphanPath(other)
            return CompatibilityFiles.ChildPath(self._reader, other)

        @property
        def name(self):
            return self._spec.name

        def open(self, mode='r', *args, **kwargs):
            return _io_wrapper(self._reader.open_resource(None), mode, *args, **kwargs)

    class ChildPath(abc.Traversable):
        """
        Path tied to a resource reader child.
        Can be read but doesn't expose any meaningful children.
        """

        def __init__(self, reader, name):
            self._reader = reader
            self._name = name

        def iterdir(self):
            return iter(())

        def is_file(self):
            return self._reader.is_resource(self.name)

        def is_dir(self):
            return not self.is_file()

        def joinpath(self, other):
            return CompatibilityFiles.OrphanPath(self.name, other)

        @property
        def name(self):
            return self._name

        def open(self, mode='r', *args, **kwargs):
            return _io_wrapper(
                self._reader.open_resource(self.name), mode, *args, **kwargs
            )

    class OrphanPath(abc.Traversable):
        """
        Orphan path, not tied to a module spec or resource reader.
        Can't be read and doesn't expose any meaningful children.
        """

        def __init__(self, *path_parts):
            if len(path_parts) < 1:
                raise ValueError('Need at least one path part to construct a path')
            self._path = path_parts

        def iterdir(self):
            return iter(())

        def is_file(self):
            return False

        is_dir = is_file

        def joinpath(self, other):
            return CompatibilityFiles.OrphanPath(*self._path, other)

        @property
        def name(self):
            return self._path[-1]

        def open(self, mode='r', *args, **kwargs):
            raise FileNotFoundError("Can't open orphan path")

    def __init__(self, spec):
        self.spec = spec

    @property
    def _reader(self):
        with suppress(AttributeError):
            return self.spec.loader.get_resource_reader(self.spec.name)

    def _native(self):
        """
        Return the native reader if it supports files().
        """
        reader = self._reader
        return reader if hasattr(reader, 'files') else self

    def __getattr__(self, attr):
        return getattr(self._reader, attr)

    def files(self):
        return CompatibilityFiles.SpecPath(self.spec, self._reader)


def wrap_spec(package):
    """
    Construct a package spec with traversable compatibility
    on the spec/loader/reader.
    """
    return SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/_common.py0000644000175100001730000001252114467657412025424 0ustar00runnerdockerimport os
import pathlib
import tempfile
import functools
import contextlib
import types
import importlib
import inspect
import warnings
import itertools

from typing import Union, Optional, cast
from .abc import ResourceReader, Traversable

from ._compat import wrap_spec

Package = Union[types.ModuleType, str]
Anchor = Package


def package_to_anchor(func):
    """
    Replace 'package' parameter as 'anchor' and warn about the change.

    Other errors should fall through.

    >>> files('a', 'b')
    Traceback (most recent call last):
    TypeError: files() takes from 0 to 1 positional arguments but 2 were given
    """
    undefined = object()

    @functools.wraps(func)
    def wrapper(anchor=undefined, package=undefined):
        if package is not undefined:
            if anchor is not undefined:
                return func(anchor, package)
            warnings.warn(
                "First parameter to files is renamed to 'anchor'",
                DeprecationWarning,
                stacklevel=2,
            )
            return func(package)
        elif anchor is undefined:
            return func()
        return func(anchor)

    return wrapper


@package_to_anchor
def files(anchor: Optional[Anchor] = None) -> Traversable:
    """
    Get a Traversable resource for an anchor.
    """
    return from_package(resolve(anchor))


def get_resource_reader(package: types.ModuleType) -> Optional[ResourceReader]:
    """
    Return the package's loader if it's a ResourceReader.
    """
    # We can't use
    # a issubclass() check here because apparently abc.'s __subclasscheck__()
    # hook wants to create a weak reference to the object, but
    # zipimport.zipimporter does not support weak references, resulting in a
    # TypeError.  That seems terrible.
    spec = package.__spec__
    reader = getattr(spec.loader, 'get_resource_reader', None)  # type: ignore
    if reader is None:
        return None
    return reader(spec.name)  # type: ignore


@functools.singledispatch
def resolve(cand: Optional[Anchor]) -> types.ModuleType:
    return cast(types.ModuleType, cand)


@resolve.register
def _(cand: str) -> types.ModuleType:
    return importlib.import_module(cand)


@resolve.register
def _(cand: None) -> types.ModuleType:
    return resolve(_infer_caller().f_globals['__name__'])


def _infer_caller():
    """
    Walk the stack and find the frame of the first caller not in this module.
    """

    def is_this_file(frame_info):
        return frame_info.filename == __file__

    def is_wrapper(frame_info):
        return frame_info.function == 'wrapper'

    not_this_file = itertools.filterfalse(is_this_file, inspect.stack())
    # also exclude 'wrapper' due to singledispatch in the call stack
    callers = itertools.filterfalse(is_wrapper, not_this_file)
    return next(callers).frame


def from_package(package: types.ModuleType):
    """
    Return a Traversable object for the given package.

    """
    spec = wrap_spec(package)
    reader = spec.loader.get_resource_reader(spec.name)
    return reader.files()


@contextlib.contextmanager
def _tempfile(
    reader,
    suffix='',
    # gh-93353: Keep a reference to call os.remove() in late Python
    # finalization.
    *,
    _os_remove=os.remove,
):
    # Not using tempfile.NamedTemporaryFile as it leads to deeper 'try'
    # blocks due to the need to close the temporary file to work on Windows
    # properly.
    fd, raw_path = tempfile.mkstemp(suffix=suffix)
    try:
        try:
            os.write(fd, reader())
        finally:
            os.close(fd)
        del reader
        yield pathlib.Path(raw_path)
    finally:
        try:
            _os_remove(raw_path)
        except FileNotFoundError:
            pass


def _temp_file(path):
    return _tempfile(path.read_bytes, suffix=path.name)


def _is_present_dir(path: Traversable) -> bool:
    """
    Some Traversables implement ``is_dir()`` to raise an
    exception (i.e. ``FileNotFoundError``) when the
    directory doesn't exist. This function wraps that call
    to always return a boolean and only return True
    if there's a dir and it exists.
    """
    with contextlib.suppress(FileNotFoundError):
        return path.is_dir()
    return False


@functools.singledispatch
def as_file(path):
    """
    Given a Traversable object, return that object as a
    path on the local file system in a context manager.
    """
    return _temp_dir(path) if _is_present_dir(path) else _temp_file(path)


@as_file.register(pathlib.Path)
@contextlib.contextmanager
def _(path):
    """
    Degenerate behavior for pathlib.Path objects.
    """
    yield path


@contextlib.contextmanager
def _temp_path(dir: tempfile.TemporaryDirectory):
    """
    Wrap tempfile.TemporyDirectory to return a pathlib object.
    """
    with dir as result:
        yield pathlib.Path(result)


@contextlib.contextmanager
def _temp_dir(path):
    """
    Given a traversable dir, recursively replicate the whole tree
    to the file system in a context manager.
    """
    assert path.is_dir()
    with _temp_path(tempfile.TemporaryDirectory()) as temp_dir:
        yield _write_contents(temp_dir, path)


def _write_contents(target, source):
    child = target.joinpath(source.name)
    if source.is_dir():
        child.mkdir()
        for item in source.iterdir():
            _write_contents(child, item)
    else:
        child.write_bytes(source.read_bytes())
    return child
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/_compat.py0000644000175100001730000000555514467657412025430 0ustar00runnerdocker# flake8: noqa

import abc
import os
import sys
import pathlib
from contextlib import suppress
from typing import Union


if sys.version_info >= (3, 10):
    from zipfile import Path as ZipPath  # type: ignore
else:
    from ..zipp import Path as ZipPath  # type: ignore


try:
    from typing import runtime_checkable  # type: ignore
except ImportError:

    def runtime_checkable(cls):  # type: ignore
        return cls


try:
    from typing import Protocol  # type: ignore
except ImportError:
    Protocol = abc.ABC  # type: ignore


class TraversableResourcesLoader:
    """
    Adapt loaders to provide TraversableResources and other
    compatibility.

    Used primarily for Python 3.9 and earlier where the native
    loaders do not yet implement TraversableResources.
    """

    def __init__(self, spec):
        self.spec = spec

    @property
    def path(self):
        return self.spec.origin

    def get_resource_reader(self, name):
        from . import readers, _adapters

        def _zip_reader(spec):
            with suppress(AttributeError):
                return readers.ZipReader(spec.loader, spec.name)

        def _namespace_reader(spec):
            with suppress(AttributeError, ValueError):
                return readers.NamespaceReader(spec.submodule_search_locations)

        def _available_reader(spec):
            with suppress(AttributeError):
                return spec.loader.get_resource_reader(spec.name)

        def _native_reader(spec):
            reader = _available_reader(spec)
            return reader if hasattr(reader, 'files') else None

        def _file_reader(spec):
            try:
                path = pathlib.Path(self.path)
            except TypeError:
                return None
            if path.exists():
                return readers.FileReader(self)

        return (
            # native reader if it supplies 'files'
            _native_reader(self.spec)
            or
            # local ZipReader if a zip module
            _zip_reader(self.spec)
            or
            # local NamespaceReader if a namespace module
            _namespace_reader(self.spec)
            or
            # local FileReader
            _file_reader(self.spec)
            # fallback - adapt the spec ResourceReader to TraversableReader
            or _adapters.CompatibilityFiles(self.spec)
        )


def wrap_spec(package):
    """
    Construct a package spec with traversable compatibility
    on the spec/loader/reader.

    Supersedes _adapters.wrap_spec to use TraversableResourcesLoader
    from above for older Python compatibility (<3.10).
    """
    from . import _adapters

    return _adapters.SpecLoaderAdapter(package.__spec__, TraversableResourcesLoader)


if sys.version_info >= (3, 9):
    StrPath = Union[str, os.PathLike[str]]
else:
    # PathLike is only subscriptable at runtime in 3.9+
    StrPath = Union[str, "os.PathLike[str]"]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/_itertools.py0000644000175100001730000000156414467657412026165 0ustar00runnerdockerfrom itertools import filterfalse

from typing import (
    Callable,
    Iterable,
    Iterator,
    Optional,
    Set,
    TypeVar,
    Union,
)

# Type and type variable definitions
_T = TypeVar('_T')
_U = TypeVar('_U')


def unique_everseen(
    iterable: Iterable[_T], key: Optional[Callable[[_T], _U]] = None
) -> Iterator[_T]:
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen: Set[Union[_T, _U]] = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/_legacy.py0000644000175100001730000000663114467657412025405 0ustar00runnerdockerimport functools
import os
import pathlib
import types
import warnings

from typing import Union, Iterable, ContextManager, BinaryIO, TextIO, Any

from . import _common

Package = Union[types.ModuleType, str]
Resource = str


def deprecated(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        warnings.warn(
            f"{func.__name__} is deprecated. Use files() instead. "
            "Refer to https://importlib-resources.readthedocs.io"
            "/en/latest/using.html#migrating-from-legacy for migration advice.",
            DeprecationWarning,
            stacklevel=2,
        )
        return func(*args, **kwargs)

    return wrapper


def normalize_path(path: Any) -> str:
    """Normalize a path by ensuring it is a string.

    If the resulting string contains path separators, an exception is raised.
    """
    str_path = str(path)
    parent, file_name = os.path.split(str_path)
    if parent:
        raise ValueError(f'{path!r} must be only a file name')
    return file_name


@deprecated
def open_binary(package: Package, resource: Resource) -> BinaryIO:
    """Return a file-like object opened for binary reading of the resource."""
    return (_common.files(package) / normalize_path(resource)).open('rb')


@deprecated
def read_binary(package: Package, resource: Resource) -> bytes:
    """Return the binary contents of the resource."""
    return (_common.files(package) / normalize_path(resource)).read_bytes()


@deprecated
def open_text(
    package: Package,
    resource: Resource,
    encoding: str = 'utf-8',
    errors: str = 'strict',
) -> TextIO:
    """Return a file-like object opened for text reading of the resource."""
    return (_common.files(package) / normalize_path(resource)).open(
        'r', encoding=encoding, errors=errors
    )


@deprecated
def read_text(
    package: Package,
    resource: Resource,
    encoding: str = 'utf-8',
    errors: str = 'strict',
) -> str:
    """Return the decoded string of the resource.

    The decoding-related arguments have the same semantics as those of
    bytes.decode().
    """
    with open_text(package, resource, encoding, errors) as fp:
        return fp.read()


@deprecated
def contents(package: Package) -> Iterable[str]:
    """Return an iterable of entries in `package`.

    Note that not all entries are resources.  Specifically, directories are
    not considered resources.  Use `is_resource()` on each entry returned here
    to check if it is a resource or not.
    """
    return [path.name for path in _common.files(package).iterdir()]


@deprecated
def is_resource(package: Package, name: str) -> bool:
    """True if `name` is a resource inside `package`.

    Directories are *not* resources.
    """
    resource = normalize_path(name)
    return any(
        traversable.name == resource and traversable.is_file()
        for traversable in _common.files(package).iterdir()
    )


@deprecated
def path(
    package: Package,
    resource: Resource,
) -> ContextManager[pathlib.Path]:
    """A context manager providing a file path object to the resource.

    If the resource does not already exist on its own on the file system,
    a temporary file will be created. If the file was created, the file
    will be deleted upon exiting the context manager (no exception is
    raised if the file was deleted prior to the context manager
    exiting).
    """
    return _common.as_file(_common.files(package) / normalize_path(resource))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/abc.py0000644000175100001730000001202414467657412024520 0ustar00runnerdockerimport abc
import io
import itertools
import pathlib
from typing import Any, BinaryIO, Iterable, Iterator, NoReturn, Text, Optional

from ._compat import runtime_checkable, Protocol, StrPath


__all__ = ["ResourceReader", "Traversable", "TraversableResources"]


class ResourceReader(metaclass=abc.ABCMeta):
    """Abstract base class for loaders to provide resource reading support."""

    @abc.abstractmethod
    def open_resource(self, resource: Text) -> BinaryIO:
        """Return an opened, file-like object for binary reading.

        The 'resource' argument is expected to represent only a file name.
        If the resource cannot be found, FileNotFoundError is raised.
        """
        # This deliberately raises FileNotFoundError instead of
        # NotImplementedError so that if this method is accidentally called,
        # it'll still do the right thing.
        raise FileNotFoundError

    @abc.abstractmethod
    def resource_path(self, resource: Text) -> Text:
        """Return the file system path to the specified resource.

        The 'resource' argument is expected to represent only a file name.
        If the resource does not exist on the file system, raise
        FileNotFoundError.
        """
        # This deliberately raises FileNotFoundError instead of
        # NotImplementedError so that if this method is accidentally called,
        # it'll still do the right thing.
        raise FileNotFoundError

    @abc.abstractmethod
    def is_resource(self, path: Text) -> bool:
        """Return True if the named 'path' is a resource.

        Files are resources, directories are not.
        """
        raise FileNotFoundError

    @abc.abstractmethod
    def contents(self) -> Iterable[str]:
        """Return an iterable of entries in `package`."""
        raise FileNotFoundError


class TraversalError(Exception):
    pass


@runtime_checkable
class Traversable(Protocol):
    """
    An object with a subset of pathlib.Path methods suitable for
    traversing directories and opening files.

    Any exceptions that occur when accessing the backing resource
    may propagate unaltered.
    """

    @abc.abstractmethod
    def iterdir(self) -> Iterator["Traversable"]:
        """
        Yield Traversable objects in self
        """

    def read_bytes(self) -> bytes:
        """
        Read contents of self as bytes
        """
        with self.open('rb') as strm:
            return strm.read()

    def read_text(self, encoding: Optional[str] = None) -> str:
        """
        Read contents of self as text
        """
        with self.open(encoding=encoding) as strm:
            return strm.read()

    @abc.abstractmethod
    def is_dir(self) -> bool:
        """
        Return True if self is a directory
        """

    @abc.abstractmethod
    def is_file(self) -> bool:
        """
        Return True if self is a file
        """

    def joinpath(self, *descendants: StrPath) -> "Traversable":
        """
        Return Traversable resolved with any descendants applied.

        Each descendant should be a path segment relative to self
        and each may contain multiple levels separated by
        ``posixpath.sep`` (``/``).
        """
        if not descendants:
            return self
        names = itertools.chain.from_iterable(
            path.parts for path in map(pathlib.PurePosixPath, descendants)
        )
        target = next(names)
        matches = (
            traversable for traversable in self.iterdir() if traversable.name == target
        )
        try:
            match = next(matches)
        except StopIteration:
            raise TraversalError(
                "Target not found during traversal.", target, list(names)
            )
        return match.joinpath(*names)

    def __truediv__(self, child: StrPath) -> "Traversable":
        """
        Return Traversable child in self
        """
        return self.joinpath(child)

    @abc.abstractmethod
    def open(self, mode='r', *args, **kwargs):
        """
        mode may be 'r' or 'rb' to open as text or binary. Return a handle
        suitable for reading (same as pathlib.Path.open).

        When opening as text, accepts encoding parameters such as those
        accepted by io.TextIOWrapper.
        """

    @property
    @abc.abstractmethod
    def name(self) -> str:
        """
        The base name of this object without any parent references.
        """


class TraversableResources(ResourceReader):
    """
    The required interface for providing traversable
    resources.
    """

    @abc.abstractmethod
    def files(self) -> "Traversable":
        """Return a Traversable object for the loaded package."""

    def open_resource(self, resource: StrPath) -> io.BufferedReader:
        return self.files().joinpath(resource).open('rb')

    def resource_path(self, resource: Any) -> NoReturn:
        raise FileNotFoundError(resource)

    def is_resource(self, path: StrPath) -> bool:
        return self.files().joinpath(path).is_file()

    def contents(self) -> Iterator[str]:
        return (item.name for item in self.files().iterdir())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/readers.py0000644000175100001730000000677514467657412025440 0ustar00runnerdockerimport collections
import pathlib
import operator

from . import abc

from ._itertools import unique_everseen
from ._compat import ZipPath


def remove_duplicates(items):
    return iter(collections.OrderedDict.fromkeys(items))


class FileReader(abc.TraversableResources):
    def __init__(self, loader):
        self.path = pathlib.Path(loader.path).parent

    def resource_path(self, resource):
        """
        Return the file system path to prevent
        `resources.path()` from creating a temporary
        copy.
        """
        return str(self.path.joinpath(resource))

    def files(self):
        return self.path


class ZipReader(abc.TraversableResources):
    def __init__(self, loader, module):
        _, _, name = module.rpartition('.')
        self.prefix = loader.prefix.replace('\\', '/') + name + '/'
        self.archive = loader.archive

    def open_resource(self, resource):
        try:
            return super().open_resource(resource)
        except KeyError as exc:
            raise FileNotFoundError(exc.args[0])

    def is_resource(self, path):
        # workaround for `zipfile.Path.is_file` returning true
        # for non-existent paths.
        target = self.files().joinpath(path)
        return target.is_file() and target.exists()

    def files(self):
        return ZipPath(self.archive, self.prefix)


class MultiplexedPath(abc.Traversable):
    """
    Given a series of Traversable objects, implement a merged
    version of the interface across all objects. Useful for
    namespace packages which may be multihomed at a single
    name.
    """

    def __init__(self, *paths):
        self._paths = list(map(pathlib.Path, remove_duplicates(paths)))
        if not self._paths:
            message = 'MultiplexedPath must contain at least one path'
            raise FileNotFoundError(message)
        if not all(path.is_dir() for path in self._paths):
            raise NotADirectoryError('MultiplexedPath only supports directories')

    def iterdir(self):
        files = (file for path in self._paths for file in path.iterdir())
        return unique_everseen(files, key=operator.attrgetter('name'))

    def read_bytes(self):
        raise FileNotFoundError(f'{self} is not a file')

    def read_text(self, *args, **kwargs):
        raise FileNotFoundError(f'{self} is not a file')

    def is_dir(self):
        return True

    def is_file(self):
        return False

    def joinpath(self, *descendants):
        try:
            return super().joinpath(*descendants)
        except abc.TraversalError:
            # One of the paths did not resolve (a directory does not exist).
            # Just return something that will not exist.
            return self._paths[0].joinpath(*descendants)

    def open(self, *args, **kwargs):
        raise FileNotFoundError(f'{self} is not a file')

    @property
    def name(self):
        return self._paths[0].name

    def __repr__(self):
        paths = ', '.join(f"'{path}'" for path in self._paths)
        return f'MultiplexedPath({paths})'


class NamespaceReader(abc.TraversableResources):
    def __init__(self, namespace_path):
        if 'NamespacePath' not in str(namespace_path):
            raise ValueError('Invalid path')
        self.path = MultiplexedPath(*list(namespace_path))

    def resource_path(self, resource):
        """
        Return the file system path to prevent
        `resources.path()` from creating a temporary
        copy.
        """
        return str(self.path.joinpath(resource))

    def files(self):
        return self.path
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/simple.py0000644000175100001730000000502014467657412025262 0ustar00runnerdocker"""
Interface adapters for low-level readers.
"""

import abc
import io
import itertools
from typing import BinaryIO, List

from .abc import Traversable, TraversableResources


class SimpleReader(abc.ABC):
    """
    The minimum, low-level interface required from a resource
    provider.
    """

    @property
    @abc.abstractmethod
    def package(self) -> str:
        """
        The name of the package for which this reader loads resources.
        """

    @abc.abstractmethod
    def children(self) -> List['SimpleReader']:
        """
        Obtain an iterable of SimpleReader for available
        child containers (e.g. directories).
        """

    @abc.abstractmethod
    def resources(self) -> List[str]:
        """
        Obtain available named resources for this virtual package.
        """

    @abc.abstractmethod
    def open_binary(self, resource: str) -> BinaryIO:
        """
        Obtain a File-like for a named resource.
        """

    @property
    def name(self):
        return self.package.split('.')[-1]


class ResourceContainer(Traversable):
    """
    Traversable container for a package's resources via its reader.
    """

    def __init__(self, reader: SimpleReader):
        self.reader = reader

    def is_dir(self):
        return True

    def is_file(self):
        return False

    def iterdir(self):
        files = (ResourceHandle(self, name) for name in self.reader.resources)
        dirs = map(ResourceContainer, self.reader.children())
        return itertools.chain(files, dirs)

    def open(self, *args, **kwargs):
        raise IsADirectoryError()


class ResourceHandle(Traversable):
    """
    Handle to a named resource in a ResourceReader.
    """

    def __init__(self, parent: ResourceContainer, name: str):
        self.parent = parent
        self.name = name  # type: ignore

    def is_file(self):
        return True

    def is_dir(self):
        return False

    def open(self, mode='r', *args, **kwargs):
        stream = self.parent.reader.open_binary(self.name)
        if 'b' not in mode:
            stream = io.TextIOWrapper(*args, **kwargs)
        return stream

    def joinpath(self, name):
        raise RuntimeError("Cannot traverse into a resource")


class TraversableReader(TraversableResources, SimpleReader):
    """
    A TraversableResources based on SimpleReader. Resource providers
    may derive from this class to provide the TraversableResources
    interface by supplying the SimpleReader interface.
    """

    def files(self):
        return ResourceContainer(self)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/0000755000175100001730000000000014467657444024571 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/__init__.py0000644000175100001730000000000014467657412026663 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/_compat.py0000644000175100001730000000130414467657412026556 0ustar00runnerdockerimport os


try:
    from test.support import import_helper  # type: ignore
except ImportError:
    # Python 3.9 and earlier
    class import_helper:  # type: ignore
        from test.support import (
            modules_setup,
            modules_cleanup,
            DirsOnSysPath,
            CleanImport,
        )


try:
    from test.support import os_helper  # type: ignore
except ImportError:
    # Python 3.9 compat
    class os_helper:  # type:ignore
        from test.support import temp_dir


try:
    # Python 3.10
    from test.support.os_helper import unlink
except ImportError:
    from test.support import unlink as _unlink

    def unlink(target):
        return _unlink(os.fspath(target))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/_path.py0000644000175100001730000000201714467657412026231 0ustar00runnerdockerimport pathlib
import functools


####
# from jaraco.path 3.4


def build(spec, prefix=pathlib.Path()):
    """
    Build a set of files/directories, as described by the spec.

    Each key represents a pathname, and the value represents
    the content. Content may be a nested directory.

    >>> spec = {
    ...     'README.txt': "A README file",
    ...     "foo": {
    ...         "__init__.py": "",
    ...         "bar": {
    ...             "__init__.py": "",
    ...         },
    ...         "baz.py": "# Some code",
    ...     }
    ... }
    >>> tmpdir = getfixture('tmpdir')
    >>> build(spec, tmpdir)
    """
    for name, contents in spec.items():
        create(contents, pathlib.Path(prefix) / name)


@functools.singledispatch
def create(content, path):
    path.mkdir(exist_ok=True)
    build(content, prefix=path)  # type: ignore


@create.register
def _(content: bytes, path):
    path.write_bytes(content)


@create.register
def _(content: str, path):
    path.write_text(content)


# end from jaraco.path
####
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data01/0000755000175100001730000000000014467657444025643 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data01/__init__.py0000644000175100001730000000000014467657412027735 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data01/subdirectory/0000755000175100001730000000000014467657444030361 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data01/subdirectory/__init__.py0000644000175100001730000000000014467657412032453 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/0000755000175100001730000000000014467657444025644 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/__init__.py0000644000175100001730000000000014467657412027736 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/one/0000755000175100001730000000000014467657444026425 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/one/__init__.py0000644000175100001730000000000014467657412030517 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/one/resource1.txt0000644000175100001730000000001514467657412031065 0ustar00runnerdockerone resource
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/two/0000755000175100001730000000000014467657444026455 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/two/__init__.py0000644000175100001730000000000014467657412030547 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/data02/two/resource2.txt0000644000175100001730000000001514467657412031116 0ustar00runnerdockertwo resource
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_compatibilty_files.py0000644000175100001730000000627414467657412032070 0ustar00runnerdockerimport io
import unittest

import importlib_resources as resources

from importlib_resources._adapters import (
    CompatibilityFiles,
    wrap_spec,
)

from . import util


class CompatibilityFilesTests(unittest.TestCase):
    @property
    def package(self):
        bytes_data = io.BytesIO(b'Hello, world!')
        return util.create_package(
            file=bytes_data,
            path='some_path',
            contents=('a', 'b', 'c'),
        )

    @property
    def files(self):
        return resources.files(self.package)

    def test_spec_path_iter(self):
        self.assertEqual(
            sorted(path.name for path in self.files.iterdir()),
            ['a', 'b', 'c'],
        )

    def test_child_path_iter(self):
        self.assertEqual(list((self.files / 'a').iterdir()), [])

    def test_orphan_path_iter(self):
        self.assertEqual(list((self.files / 'a' / 'a').iterdir()), [])
        self.assertEqual(list((self.files / 'a' / 'a' / 'a').iterdir()), [])

    def test_spec_path_is(self):
        self.assertFalse(self.files.is_file())
        self.assertFalse(self.files.is_dir())

    def test_child_path_is(self):
        self.assertTrue((self.files / 'a').is_file())
        self.assertFalse((self.files / 'a').is_dir())

    def test_orphan_path_is(self):
        self.assertFalse((self.files / 'a' / 'a').is_file())
        self.assertFalse((self.files / 'a' / 'a').is_dir())
        self.assertFalse((self.files / 'a' / 'a' / 'a').is_file())
        self.assertFalse((self.files / 'a' / 'a' / 'a').is_dir())

    def test_spec_path_name(self):
        self.assertEqual(self.files.name, 'testingpackage')

    def test_child_path_name(self):
        self.assertEqual((self.files / 'a').name, 'a')

    def test_orphan_path_name(self):
        self.assertEqual((self.files / 'a' / 'b').name, 'b')
        self.assertEqual((self.files / 'a' / 'b' / 'c').name, 'c')

    def test_spec_path_open(self):
        self.assertEqual(self.files.read_bytes(), b'Hello, world!')
        self.assertEqual(self.files.read_text(), 'Hello, world!')

    def test_child_path_open(self):
        self.assertEqual((self.files / 'a').read_bytes(), b'Hello, world!')
        self.assertEqual((self.files / 'a').read_text(), 'Hello, world!')

    def test_orphan_path_open(self):
        with self.assertRaises(FileNotFoundError):
            (self.files / 'a' / 'b').read_bytes()
        with self.assertRaises(FileNotFoundError):
            (self.files / 'a' / 'b' / 'c').read_bytes()

    def test_open_invalid_mode(self):
        with self.assertRaises(ValueError):
            self.files.open('0')

    def test_orphan_path_invalid(self):
        with self.assertRaises(ValueError):
            CompatibilityFiles.OrphanPath()

    def test_wrap_spec(self):
        spec = wrap_spec(self.package)
        self.assertIsInstance(spec.loader.get_resource_reader(None), CompatibilityFiles)


class CompatibilityFilesNoReaderTests(unittest.TestCase):
    @property
    def package(self):
        return util.create_package_from_loader(None)

    @property
    def files(self):
        return resources.files(self.package)

    def test_spec_path_joinpath(self):
        self.assertIsInstance(self.files / 'a', CompatibilityFiles.OrphanPath)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_contents.py0000644000175100001730000000171014467657412030031 0ustar00runnerdockerimport unittest
import importlib_resources as resources

from . import data01
from . import util


class ContentsTests:
    expected = {
        '__init__.py',
        'binary.file',
        'subdirectory',
        'utf-16.file',
        'utf-8.file',
    }

    def test_contents(self):
        contents = {path.name for path in resources.files(self.data).iterdir()}
        assert self.expected <= contents


class ContentsDiskTests(ContentsTests, unittest.TestCase):
    def setUp(self):
        self.data = data01


class ContentsZipTests(ContentsTests, util.ZipSetup, unittest.TestCase):
    pass


class ContentsNamespaceTests(ContentsTests, unittest.TestCase):
    expected = {
        # no __init__ because of namespace design
        # no subdirectory as incidental difference in fixture
        'binary.file',
        'utf-16.file',
        'utf-8.file',
    }

    def setUp(self):
        from . import namespacedata01

        self.data = namespacedata01
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_files.py0000644000175100001730000000626314467657412027306 0ustar00runnerdockerimport typing
import textwrap
import unittest
import warnings
import importlib
import contextlib

import importlib_resources as resources
from ..abc import Traversable
from . import data01
from . import util
from . import _path
from ._compat import os_helper, import_helper


@contextlib.contextmanager
def suppress_known_deprecation():
    with warnings.catch_warnings(record=True) as ctx:
        warnings.simplefilter('default', category=DeprecationWarning)
        yield ctx


class FilesTests:
    def test_read_bytes(self):
        files = resources.files(self.data)
        actual = files.joinpath('utf-8.file').read_bytes()
        assert actual == b'Hello, UTF-8 world!\n'

    def test_read_text(self):
        files = resources.files(self.data)
        actual = files.joinpath('utf-8.file').read_text(encoding='utf-8')
        assert actual == 'Hello, UTF-8 world!\n'

    @unittest.skipUnless(
        hasattr(typing, 'runtime_checkable'),
        "Only suitable when typing supports runtime_checkable",
    )
    def test_traversable(self):
        assert isinstance(resources.files(self.data), Traversable)

    def test_old_parameter(self):
        """
        Files used to take a 'package' parameter. Make sure anyone
        passing by name is still supported.
        """
        with suppress_known_deprecation():
            resources.files(package=self.data)


class OpenDiskTests(FilesTests, unittest.TestCase):
    def setUp(self):
        self.data = data01


class OpenZipTests(FilesTests, util.ZipSetup, unittest.TestCase):
    pass


class OpenNamespaceTests(FilesTests, unittest.TestCase):
    def setUp(self):
        from . import namespacedata01

        self.data = namespacedata01


class SiteDir:
    def setUp(self):
        self.fixtures = contextlib.ExitStack()
        self.addCleanup(self.fixtures.close)
        self.site_dir = self.fixtures.enter_context(os_helper.temp_dir())
        self.fixtures.enter_context(import_helper.DirsOnSysPath(self.site_dir))
        self.fixtures.enter_context(import_helper.CleanImport())


class ModulesFilesTests(SiteDir, unittest.TestCase):
    def test_module_resources(self):
        """
        A module can have resources found adjacent to the module.
        """
        spec = {
            'mod.py': '',
            'res.txt': 'resources are the best',
        }
        _path.build(spec, self.site_dir)
        import mod

        actual = resources.files(mod).joinpath('res.txt').read_text()
        assert actual == spec['res.txt']


class ImplicitContextFilesTests(SiteDir, unittest.TestCase):
    def test_implicit_files(self):
        """
        Without any parameter, files() will infer the location as the caller.
        """
        spec = {
            'somepkg': {
                '__init__.py': textwrap.dedent(
                    """
                    import importlib_resources as res
                    val = res.files().joinpath('res.txt').read_text()
                    """
                ),
                'res.txt': 'resources are the best',
            },
        }
        _path.build(spec, self.site_dir)
        assert importlib.import_module('somepkg').val == 'resources are the best'


if __name__ == '__main__':
    unittest.main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_open.py0000644000175100001730000000500514467657412027136 0ustar00runnerdockerimport unittest

import importlib_resources as resources
from . import data01
from . import util


class CommonBinaryTests(util.CommonTests, unittest.TestCase):
    def execute(self, package, path):
        target = resources.files(package).joinpath(path)
        with target.open('rb'):
            pass


class CommonTextTests(util.CommonTests, unittest.TestCase):
    def execute(self, package, path):
        target = resources.files(package).joinpath(path)
        with target.open():
            pass


class OpenTests:
    def test_open_binary(self):
        target = resources.files(self.data) / 'binary.file'
        with target.open('rb') as fp:
            result = fp.read()
            self.assertEqual(result, b'\x00\x01\x02\x03')

    def test_open_text_default_encoding(self):
        target = resources.files(self.data) / 'utf-8.file'
        with target.open() as fp:
            result = fp.read()
            self.assertEqual(result, 'Hello, UTF-8 world!\n')

    def test_open_text_given_encoding(self):
        target = resources.files(self.data) / 'utf-16.file'
        with target.open(encoding='utf-16', errors='strict') as fp:
            result = fp.read()
        self.assertEqual(result, 'Hello, UTF-16 world!\n')

    def test_open_text_with_errors(self):
        # Raises UnicodeError without the 'errors' argument.
        target = resources.files(self.data) / 'utf-16.file'
        with target.open(encoding='utf-8', errors='strict') as fp:
            self.assertRaises(UnicodeError, fp.read)
        with target.open(encoding='utf-8', errors='ignore') as fp:
            result = fp.read()
        self.assertEqual(
            result,
            'H\x00e\x00l\x00l\x00o\x00,\x00 '
            '\x00U\x00T\x00F\x00-\x001\x006\x00 '
            '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00',
        )

    def test_open_binary_FileNotFoundError(self):
        target = resources.files(self.data) / 'does-not-exist'
        self.assertRaises(FileNotFoundError, target.open, 'rb')

    def test_open_text_FileNotFoundError(self):
        target = resources.files(self.data) / 'does-not-exist'
        self.assertRaises(FileNotFoundError, target.open)


class OpenDiskTests(OpenTests, unittest.TestCase):
    def setUp(self):
        self.data = data01


class OpenDiskNamespaceTests(OpenTests, unittest.TestCase):
    def setUp(self):
        from . import namespacedata01

        self.data = namespacedata01


class OpenZipTests(OpenTests, util.ZipSetup, unittest.TestCase):
    pass


if __name__ == '__main__':
    unittest.main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_path.py0000644000175100001730000000406714467657412027140 0ustar00runnerdockerimport io
import unittest

import importlib_resources as resources
from . import data01
from . import util


class CommonTests(util.CommonTests, unittest.TestCase):
    def execute(self, package, path):
        with resources.as_file(resources.files(package).joinpath(path)):
            pass


class PathTests:
    def test_reading(self):
        # Path should be readable.
        # Test also implicitly verifies the returned object is a pathlib.Path
        # instance.
        target = resources.files(self.data) / 'utf-8.file'
        with resources.as_file(target) as path:
            self.assertTrue(path.name.endswith("utf-8.file"), repr(path))
            # pathlib.Path.read_text() was introduced in Python 3.5.
            with path.open('r', encoding='utf-8') as file:
                text = file.read()
            self.assertEqual('Hello, UTF-8 world!\n', text)


class PathDiskTests(PathTests, unittest.TestCase):
    data = data01

    def test_natural_path(self):
        """
        Guarantee the internal implementation detail that
        file-system-backed resources do not get the tempdir
        treatment.
        """
        target = resources.files(self.data) / 'utf-8.file'
        with resources.as_file(target) as path:
            assert 'data' in str(path)


class PathMemoryTests(PathTests, unittest.TestCase):
    def setUp(self):
        file = io.BytesIO(b'Hello, UTF-8 world!\n')
        self.addCleanup(file.close)
        self.data = util.create_package(
            file=file, path=FileNotFoundError("package exists only in memory")
        )
        self.data.__spec__.origin = None
        self.data.__spec__.has_location = False


class PathZipTests(PathTests, util.ZipSetup, unittest.TestCase):
    def test_remove_in_context_manager(self):
        # It is not an error if the file that was temporarily stashed on the
        # file system is removed inside the `with` stanza.
        target = resources.files(self.data) / 'utf-8.file'
        with resources.as_file(target) as path:
            path.unlink()


if __name__ == '__main__':
    unittest.main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_read.py0000644000175100001730000000455014467657412027114 0ustar00runnerdockerimport unittest
import importlib_resources as resources

from . import data01
from . import util
from importlib import import_module


class CommonBinaryTests(util.CommonTests, unittest.TestCase):
    def execute(self, package, path):
        resources.files(package).joinpath(path).read_bytes()


class CommonTextTests(util.CommonTests, unittest.TestCase):
    def execute(self, package, path):
        resources.files(package).joinpath(path).read_text()


class ReadTests:
    def test_read_bytes(self):
        result = resources.files(self.data).joinpath('binary.file').read_bytes()
        self.assertEqual(result, b'\0\1\2\3')

    def test_read_text_default_encoding(self):
        result = resources.files(self.data).joinpath('utf-8.file').read_text()
        self.assertEqual(result, 'Hello, UTF-8 world!\n')

    def test_read_text_given_encoding(self):
        result = (
            resources.files(self.data)
            .joinpath('utf-16.file')
            .read_text(encoding='utf-16')
        )
        self.assertEqual(result, 'Hello, UTF-16 world!\n')

    def test_read_text_with_errors(self):
        # Raises UnicodeError without the 'errors' argument.
        target = resources.files(self.data) / 'utf-16.file'
        self.assertRaises(UnicodeError, target.read_text, encoding='utf-8')
        result = target.read_text(encoding='utf-8', errors='ignore')
        self.assertEqual(
            result,
            'H\x00e\x00l\x00l\x00o\x00,\x00 '
            '\x00U\x00T\x00F\x00-\x001\x006\x00 '
            '\x00w\x00o\x00r\x00l\x00d\x00!\x00\n\x00',
        )


class ReadDiskTests(ReadTests, unittest.TestCase):
    data = data01


class ReadZipTests(ReadTests, util.ZipSetup, unittest.TestCase):
    def test_read_submodule_resource(self):
        submodule = import_module('ziptestdata.subdirectory')
        result = resources.files(submodule).joinpath('binary.file').read_bytes()
        self.assertEqual(result, b'\0\1\2\3')

    def test_read_submodule_resource_by_name(self):
        result = (
            resources.files('ziptestdata.subdirectory')
            .joinpath('binary.file')
            .read_bytes()
        )
        self.assertEqual(result, b'\0\1\2\3')


class ReadNamespaceTests(ReadTests, unittest.TestCase):
    def setUp(self):
        from . import namespacedata01

        self.data = namespacedata01


if __name__ == '__main__':
    unittest.main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_reader.py0000644000175100001730000001060014467657412027434 0ustar00runnerdockerimport os.path
import sys
import pathlib
import unittest

from importlib import import_module
from importlib_resources.readers import MultiplexedPath, NamespaceReader


class MultiplexedPathTest(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        path = pathlib.Path(__file__).parent / 'namespacedata01'
        cls.folder = str(path)

    def test_init_no_paths(self):
        with self.assertRaises(FileNotFoundError):
            MultiplexedPath()

    def test_init_file(self):
        with self.assertRaises(NotADirectoryError):
            MultiplexedPath(os.path.join(self.folder, 'binary.file'))

    def test_iterdir(self):
        contents = {path.name for path in MultiplexedPath(self.folder).iterdir()}
        try:
            contents.remove('__pycache__')
        except (KeyError, ValueError):
            pass
        self.assertEqual(contents, {'binary.file', 'utf-16.file', 'utf-8.file'})

    def test_iterdir_duplicate(self):
        data01 = os.path.abspath(os.path.join(__file__, '..', 'data01'))
        contents = {
            path.name for path in MultiplexedPath(self.folder, data01).iterdir()
        }
        for remove in ('__pycache__', '__init__.pyc'):
            try:
                contents.remove(remove)
            except (KeyError, ValueError):
                pass
        self.assertEqual(
            contents,
            {'__init__.py', 'binary.file', 'subdirectory', 'utf-16.file', 'utf-8.file'},
        )

    def test_is_dir(self):
        self.assertEqual(MultiplexedPath(self.folder).is_dir(), True)

    def test_is_file(self):
        self.assertEqual(MultiplexedPath(self.folder).is_file(), False)

    def test_open_file(self):
        path = MultiplexedPath(self.folder)
        with self.assertRaises(FileNotFoundError):
            path.read_bytes()
        with self.assertRaises(FileNotFoundError):
            path.read_text()
        with self.assertRaises(FileNotFoundError):
            path.open()

    def test_join_path(self):
        prefix = os.path.abspath(os.path.join(__file__, '..'))
        data01 = os.path.join(prefix, 'data01')
        path = MultiplexedPath(self.folder, data01)
        self.assertEqual(
            str(path.joinpath('binary.file'))[len(prefix) + 1 :],
            os.path.join('namespacedata01', 'binary.file'),
        )
        self.assertEqual(
            str(path.joinpath('subdirectory'))[len(prefix) + 1 :],
            os.path.join('data01', 'subdirectory'),
        )
        self.assertEqual(
            str(path.joinpath('imaginary'))[len(prefix) + 1 :],
            os.path.join('namespacedata01', 'imaginary'),
        )
        self.assertEqual(path.joinpath(), path)

    def test_join_path_compound(self):
        path = MultiplexedPath(self.folder)
        assert not path.joinpath('imaginary/foo.py').exists()

    def test_repr(self):
        self.assertEqual(
            repr(MultiplexedPath(self.folder)),
            f"MultiplexedPath('{self.folder}')",
        )

    def test_name(self):
        self.assertEqual(
            MultiplexedPath(self.folder).name,
            os.path.basename(self.folder),
        )


class NamespaceReaderTest(unittest.TestCase):
    site_dir = str(pathlib.Path(__file__).parent)

    @classmethod
    def setUpClass(cls):
        sys.path.append(cls.site_dir)

    @classmethod
    def tearDownClass(cls):
        sys.path.remove(cls.site_dir)

    def test_init_error(self):
        with self.assertRaises(ValueError):
            NamespaceReader(['path1', 'path2'])

    def test_resource_path(self):
        namespacedata01 = import_module('namespacedata01')
        reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)

        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
        self.assertEqual(
            reader.resource_path('binary.file'), os.path.join(root, 'binary.file')
        )
        self.assertEqual(
            reader.resource_path('imaginary'), os.path.join(root, 'imaginary')
        )

    def test_files(self):
        namespacedata01 = import_module('namespacedata01')
        reader = NamespaceReader(namespacedata01.__spec__.submodule_search_locations)
        root = os.path.abspath(os.path.join(__file__, '..', 'namespacedata01'))
        self.assertIsInstance(reader.files(), MultiplexedPath)
        self.assertEqual(repr(reader.files()), f"MultiplexedPath('{root}')")


if __name__ == '__main__':
    unittest.main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/test_resource.py0000644000175100001730000002043614467657412030031 0ustar00runnerdockerimport sys
import unittest
import importlib_resources as resources
import uuid
import pathlib

from . import data01
from . import zipdata01, zipdata02
from . import util
from importlib import import_module
from ._compat import import_helper, unlink


class ResourceTests:
    # Subclasses are expected to set the `data` attribute.

    def test_is_file_exists(self):
        target = resources.files(self.data) / 'binary.file'
        self.assertTrue(target.is_file())

    def test_is_file_missing(self):
        target = resources.files(self.data) / 'not-a-file'
        self.assertFalse(target.is_file())

    def test_is_dir(self):
        target = resources.files(self.data) / 'subdirectory'
        self.assertFalse(target.is_file())
        self.assertTrue(target.is_dir())


class ResourceDiskTests(ResourceTests, unittest.TestCase):
    def setUp(self):
        self.data = data01


class ResourceZipTests(ResourceTests, util.ZipSetup, unittest.TestCase):
    pass


def names(traversable):
    return {item.name for item in traversable.iterdir()}


class ResourceLoaderTests(unittest.TestCase):
    def test_resource_contents(self):
        package = util.create_package(
            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
        )
        self.assertEqual(names(resources.files(package)), {'A', 'B', 'C'})

    def test_is_file(self):
        package = util.create_package(
            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
        )
        self.assertTrue(resources.files(package).joinpath('B').is_file())

    def test_is_dir(self):
        package = util.create_package(
            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
        )
        self.assertTrue(resources.files(package).joinpath('D').is_dir())

    def test_resource_missing(self):
        package = util.create_package(
            file=data01, path=data01.__file__, contents=['A', 'B', 'C', 'D/E', 'D/F']
        )
        self.assertFalse(resources.files(package).joinpath('Z').is_file())


class ResourceCornerCaseTests(unittest.TestCase):
    def test_package_has_no_reader_fallback(self):
        # Test odd ball packages which:
        # 1. Do not have a ResourceReader as a loader
        # 2. Are not on the file system
        # 3. Are not in a zip file
        module = util.create_package(
            file=data01, path=data01.__file__, contents=['A', 'B', 'C']
        )
        # Give the module a dummy loader.
        module.__loader__ = object()
        # Give the module a dummy origin.
        module.__file__ = '/path/which/shall/not/be/named'
        module.__spec__.loader = module.__loader__
        module.__spec__.origin = module.__file__
        self.assertFalse(resources.files(module).joinpath('A').is_file())


class ResourceFromZipsTest01(util.ZipSetupBase, unittest.TestCase):
    ZIP_MODULE = zipdata01  # type: ignore

    def test_is_submodule_resource(self):
        submodule = import_module('ziptestdata.subdirectory')
        self.assertTrue(resources.files(submodule).joinpath('binary.file').is_file())

    def test_read_submodule_resource_by_name(self):
        self.assertTrue(
            resources.files('ziptestdata.subdirectory')
            .joinpath('binary.file')
            .is_file()
        )

    def test_submodule_contents(self):
        submodule = import_module('ziptestdata.subdirectory')
        self.assertEqual(
            names(resources.files(submodule)), {'__init__.py', 'binary.file'}
        )

    def test_submodule_contents_by_name(self):
        self.assertEqual(
            names(resources.files('ziptestdata.subdirectory')),
            {'__init__.py', 'binary.file'},
        )

    def test_as_file_directory(self):
        with resources.as_file(resources.files('ziptestdata')) as data:
            assert data.name == 'ziptestdata'
            assert data.is_dir()
            assert data.joinpath('subdirectory').is_dir()
            assert len(list(data.iterdir()))
        assert not data.parent.exists()


class ResourceFromZipsTest02(util.ZipSetupBase, unittest.TestCase):
    ZIP_MODULE = zipdata02  # type: ignore

    def test_unrelated_contents(self):
        """
        Test thata zip with two unrelated subpackages return
        distinct resources. Ref python/importlib_resources#44.
        """
        self.assertEqual(
            names(resources.files('ziptestdata.one')),
            {'__init__.py', 'resource1.txt'},
        )
        self.assertEqual(
            names(resources.files('ziptestdata.two')),
            {'__init__.py', 'resource2.txt'},
        )


class DeletingZipsTest(unittest.TestCase):
    """Having accessed resources in a zip file should not keep an open
    reference to the zip.
    """

    ZIP_MODULE = zipdata01

    def setUp(self):
        modules = import_helper.modules_setup()
        self.addCleanup(import_helper.modules_cleanup, *modules)

        data_path = pathlib.Path(self.ZIP_MODULE.__file__)
        data_dir = data_path.parent
        self.source_zip_path = data_dir / 'ziptestdata.zip'
        self.zip_path = pathlib.Path(f'{uuid.uuid4()}.zip').absolute()
        self.zip_path.write_bytes(self.source_zip_path.read_bytes())
        sys.path.append(str(self.zip_path))
        self.data = import_module('ziptestdata')

    def tearDown(self):
        try:
            sys.path.remove(str(self.zip_path))
        except ValueError:
            pass

        try:
            del sys.path_importer_cache[str(self.zip_path)]
            del sys.modules[self.data.__name__]
        except KeyError:
            pass

        try:
            unlink(self.zip_path)
        except OSError:
            # If the test fails, this will probably fail too
            pass

    def test_iterdir_does_not_keep_open(self):
        c = [item.name for item in resources.files('ziptestdata').iterdir()]
        self.zip_path.unlink()
        del c

    def test_is_file_does_not_keep_open(self):
        c = resources.files('ziptestdata').joinpath('binary.file').is_file()
        self.zip_path.unlink()
        del c

    def test_is_file_failure_does_not_keep_open(self):
        c = resources.files('ziptestdata').joinpath('not-present').is_file()
        self.zip_path.unlink()
        del c

    @unittest.skip("Desired but not supported.")
    def test_as_file_does_not_keep_open(self):  # pragma: no cover
        c = resources.as_file(resources.files('ziptestdata') / 'binary.file')
        self.zip_path.unlink()
        del c

    def test_entered_path_does_not_keep_open(self):
        # This is what certifi does on import to make its bundle
        # available for the process duration.
        c = resources.as_file(
            resources.files('ziptestdata') / 'binary.file'
        ).__enter__()
        self.zip_path.unlink()
        del c

    def test_read_binary_does_not_keep_open(self):
        c = resources.files('ziptestdata').joinpath('binary.file').read_bytes()
        self.zip_path.unlink()
        del c

    def test_read_text_does_not_keep_open(self):
        c = resources.files('ziptestdata').joinpath('utf-8.file').read_text()
        self.zip_path.unlink()
        del c


class ResourceFromNamespaceTest01(unittest.TestCase):
    site_dir = str(pathlib.Path(__file__).parent)

    @classmethod
    def setUpClass(cls):
        sys.path.append(cls.site_dir)

    @classmethod
    def tearDownClass(cls):
        sys.path.remove(cls.site_dir)

    def test_is_submodule_resource(self):
        self.assertTrue(
            resources.files(import_module('namespacedata01'))
            .joinpath('binary.file')
            .is_file()
        )

    def test_read_submodule_resource_by_name(self):
        self.assertTrue(
            resources.files('namespacedata01').joinpath('binary.file').is_file()
        )

    def test_submodule_contents(self):
        contents = names(resources.files(import_module('namespacedata01')))
        try:
            contents.remove('__pycache__')
        except KeyError:
            pass
        self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'})

    def test_submodule_contents_by_name(self):
        contents = names(resources.files('namespacedata01'))
        try:
            contents.remove('__pycache__')
        except KeyError:
            pass
        self.assertEqual(contents, {'binary.file', 'utf-8.file', 'utf-16.file'})


if __name__ == '__main__':
    unittest.main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/update-zips.py0000644000175100001730000000261114467657412027403 0ustar00runnerdocker"""
Generate the zip test data files.

Run to build the tests/zipdataNN/ziptestdata.zip files from
files in tests/dataNN.

Replaces the file with the working copy, but does commit anything
to the source repo.
"""

import contextlib
import os
import pathlib
import zipfile


def main():
    """
    >>> from unittest import mock
    >>> monkeypatch = getfixture('monkeypatch')
    >>> monkeypatch.setattr(zipfile, 'ZipFile', mock.MagicMock())
    >>> print(); main()  # print workaround for bpo-32509
    
    ...data01... -> ziptestdata/...
    ...
    ...data02... -> ziptestdata/...
    ...
    """
    suffixes = '01', '02'
    tuple(map(generate, suffixes))


def generate(suffix):
    root = pathlib.Path(__file__).parent.relative_to(os.getcwd())
    zfpath = root / f'zipdata{suffix}/ziptestdata.zip'
    with zipfile.ZipFile(zfpath, 'w') as zf:
        for src, rel in walk(root / f'data{suffix}'):
            dst = 'ziptestdata' / pathlib.PurePosixPath(rel.as_posix())
            print(src, '->', dst)
            zf.write(src, dst)


def walk(datapath):
    for dirpath, dirnames, filenames in os.walk(datapath):
        with contextlib.suppress(ValueError):
            dirnames.remove('__pycache__')
        for filename in filenames:
            res = pathlib.Path(dirpath) / filename
            rel = res.relative_to(datapath)
            yield res, rel


__name__ == '__main__' and main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/util.py0000644000175100001730000001141114467657412026111 0ustar00runnerdockerimport abc
import importlib
import io
import sys
import types
import pathlib

from . import data01
from . import zipdata01
from ..abc import ResourceReader
from ._compat import import_helper


from importlib.machinery import ModuleSpec


class Reader(ResourceReader):
    def __init__(self, **kwargs):
        vars(self).update(kwargs)

    def get_resource_reader(self, package):
        return self

    def open_resource(self, path):
        self._path = path
        if isinstance(self.file, Exception):
            raise self.file
        return self.file

    def resource_path(self, path_):
        self._path = path_
        if isinstance(self.path, Exception):
            raise self.path
        return self.path

    def is_resource(self, path_):
        self._path = path_
        if isinstance(self.path, Exception):
            raise self.path

        def part(entry):
            return entry.split('/')

        return any(
            len(parts) == 1 and parts[0] == path_ for parts in map(part, self._contents)
        )

    def contents(self):
        if isinstance(self.path, Exception):
            raise self.path
        yield from self._contents


def create_package_from_loader(loader, is_package=True):
    name = 'testingpackage'
    module = types.ModuleType(name)
    spec = ModuleSpec(name, loader, origin='does-not-exist', is_package=is_package)
    module.__spec__ = spec
    module.__loader__ = loader
    return module


def create_package(file=None, path=None, is_package=True, contents=()):
    return create_package_from_loader(
        Reader(file=file, path=path, _contents=contents),
        is_package,
    )


class CommonTests(metaclass=abc.ABCMeta):
    """
    Tests shared by test_open, test_path, and test_read.
    """

    @abc.abstractmethod
    def execute(self, package, path):
        """
        Call the pertinent legacy API function (e.g. open_text, path)
        on package and path.
        """

    def test_package_name(self):
        # Passing in the package name should succeed.
        self.execute(data01.__name__, 'utf-8.file')

    def test_package_object(self):
        # Passing in the package itself should succeed.
        self.execute(data01, 'utf-8.file')

    def test_string_path(self):
        # Passing in a string for the path should succeed.
        path = 'utf-8.file'
        self.execute(data01, path)

    def test_pathlib_path(self):
        # Passing in a pathlib.PurePath object for the path should succeed.
        path = pathlib.PurePath('utf-8.file')
        self.execute(data01, path)

    def test_importing_module_as_side_effect(self):
        # The anchor package can already be imported.
        del sys.modules[data01.__name__]
        self.execute(data01.__name__, 'utf-8.file')

    def test_missing_path(self):
        # Attempting to open or read or request the path for a
        # non-existent path should succeed if open_resource
        # can return a viable data stream.
        bytes_data = io.BytesIO(b'Hello, world!')
        package = create_package(file=bytes_data, path=FileNotFoundError())
        self.execute(package, 'utf-8.file')
        self.assertEqual(package.__loader__._path, 'utf-8.file')

    def test_extant_path(self):
        # Attempting to open or read or request the path when the
        # path does exist should still succeed. Does not assert
        # anything about the result.
        bytes_data = io.BytesIO(b'Hello, world!')
        # any path that exists
        path = __file__
        package = create_package(file=bytes_data, path=path)
        self.execute(package, 'utf-8.file')
        self.assertEqual(package.__loader__._path, 'utf-8.file')

    def test_useless_loader(self):
        package = create_package(file=FileNotFoundError(), path=FileNotFoundError())
        with self.assertRaises(FileNotFoundError):
            self.execute(package, 'utf-8.file')


class ZipSetupBase:
    ZIP_MODULE = None

    @classmethod
    def setUpClass(cls):
        data_path = pathlib.Path(cls.ZIP_MODULE.__file__)
        data_dir = data_path.parent
        cls._zip_path = str(data_dir / 'ziptestdata.zip')
        sys.path.append(cls._zip_path)
        cls.data = importlib.import_module('ziptestdata')

    @classmethod
    def tearDownClass(cls):
        try:
            sys.path.remove(cls._zip_path)
        except ValueError:
            pass

        try:
            del sys.path_importer_cache[cls._zip_path]
            del sys.modules[cls.data.__name__]
        except KeyError:
            pass

        try:
            del cls.data
            del cls._zip_path
        except AttributeError:
            pass

    def setUp(self):
        modules = import_helper.modules_setup()
        self.addCleanup(import_helper.modules_cleanup, *modules)


class ZipSetup(ZipSetupBase):
    ZIP_MODULE = zipdata01  # type: ignore
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/zipdata01/0000755000175100001730000000000014467657444026366 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/zipdata01/__init__.py0000644000175100001730000000000014467657412030460 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/zipdata02/0000755000175100001730000000000014467657444026367 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources/tests/zipdata02/__init__.py0000644000175100001730000000000014467657412030461 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/importlib_resources-5.10.2.dist-info/0000755000175100001730000000000014467657444026043 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/importlib_resources-5.10.2.dist-info/top_level.txt0000644000175100001730000000002414467657412030564 0ustar00runnerdockerimportlib_resources
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/jaraco/0000755000175100001730000000000014467657444020573 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco/__init__.py0000644000175100001730000000000014467657412022665 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco/context.py0000644000175100001730000001644414467657412022635 0ustar00runnerdockerimport os
import subprocess
import contextlib
import functools
import tempfile
import shutil
import operator
import warnings


@contextlib.contextmanager
def pushd(dir):
    """
    >>> tmp_path = getfixture('tmp_path')
    >>> with pushd(tmp_path):
    ...     assert os.getcwd() == os.fspath(tmp_path)
    >>> assert os.getcwd() != os.fspath(tmp_path)
    """

    orig = os.getcwd()
    os.chdir(dir)
    try:
        yield dir
    finally:
        os.chdir(orig)


@contextlib.contextmanager
def tarball_context(url, target_dir=None, runner=None, pushd=pushd):
    """
    Get a tarball, extract it, change to that directory, yield, then
    clean up.
    `runner` is the function to invoke commands.
    `pushd` is a context manager for changing the directory.
    """
    if target_dir is None:
        target_dir = os.path.basename(url).replace('.tar.gz', '').replace('.tgz', '')
    if runner is None:
        runner = functools.partial(subprocess.check_call, shell=True)
    else:
        warnings.warn("runner parameter is deprecated", DeprecationWarning)
    # In the tar command, use --strip-components=1 to strip the first path and
    #  then
    #  use -C to cause the files to be extracted to {target_dir}. This ensures
    #  that we always know where the files were extracted.
    runner('mkdir {target_dir}'.format(**vars()))
    try:
        getter = 'wget {url} -O -'
        extract = 'tar x{compression} --strip-components=1 -C {target_dir}'
        cmd = ' | '.join((getter, extract))
        runner(cmd.format(compression=infer_compression(url), **vars()))
        with pushd(target_dir):
            yield target_dir
    finally:
        runner('rm -Rf {target_dir}'.format(**vars()))


def infer_compression(url):
    """
    Given a URL or filename, infer the compression code for tar.

    >>> infer_compression('http://foo/bar.tar.gz')
    'z'
    >>> infer_compression('http://foo/bar.tgz')
    'z'
    >>> infer_compression('file.bz')
    'j'
    >>> infer_compression('file.xz')
    'J'
    """
    # cheat and just assume it's the last two characters
    compression_indicator = url[-2:]
    mapping = dict(gz='z', bz='j', xz='J')
    # Assume 'z' (gzip) if no match
    return mapping.get(compression_indicator, 'z')


@contextlib.contextmanager
def temp_dir(remover=shutil.rmtree):
    """
    Create a temporary directory context. Pass a custom remover
    to override the removal behavior.

    >>> import pathlib
    >>> with temp_dir() as the_dir:
    ...     assert os.path.isdir(the_dir)
    ...     _ = pathlib.Path(the_dir).joinpath('somefile').write_text('contents')
    >>> assert not os.path.exists(the_dir)
    """
    temp_dir = tempfile.mkdtemp()
    try:
        yield temp_dir
    finally:
        remover(temp_dir)


@contextlib.contextmanager
def repo_context(url, branch=None, quiet=True, dest_ctx=temp_dir):
    """
    Check out the repo indicated by url.

    If dest_ctx is supplied, it should be a context manager
    to yield the target directory for the check out.
    """
    exe = 'git' if 'git' in url else 'hg'
    with dest_ctx() as repo_dir:
        cmd = [exe, 'clone', url, repo_dir]
        if branch:
            cmd.extend(['--branch', branch])
        devnull = open(os.path.devnull, 'w')
        stdout = devnull if quiet else None
        subprocess.check_call(cmd, stdout=stdout)
        yield repo_dir


@contextlib.contextmanager
def null():
    """
    A null context suitable to stand in for a meaningful context.

    >>> with null() as value:
    ...     assert value is None
    """
    yield


class ExceptionTrap:
    """
    A context manager that will catch certain exceptions and provide an
    indication they occurred.

    >>> with ExceptionTrap() as trap:
    ...     raise Exception()
    >>> bool(trap)
    True

    >>> with ExceptionTrap() as trap:
    ...     pass
    >>> bool(trap)
    False

    >>> with ExceptionTrap(ValueError) as trap:
    ...     raise ValueError("1 + 1 is not 3")
    >>> bool(trap)
    True
    >>> trap.value
    ValueError('1 + 1 is not 3')
    >>> trap.tb
    

    >>> with ExceptionTrap(ValueError) as trap:
    ...     raise Exception()
    Traceback (most recent call last):
    ...
    Exception

    >>> bool(trap)
    False
    """

    exc_info = None, None, None

    def __init__(self, exceptions=(Exception,)):
        self.exceptions = exceptions

    def __enter__(self):
        return self

    @property
    def type(self):
        return self.exc_info[0]

    @property
    def value(self):
        return self.exc_info[1]

    @property
    def tb(self):
        return self.exc_info[2]

    def __exit__(self, *exc_info):
        type = exc_info[0]
        matches = type and issubclass(type, self.exceptions)
        if matches:
            self.exc_info = exc_info
        return matches

    def __bool__(self):
        return bool(self.type)

    def raises(self, func, *, _test=bool):
        """
        Wrap func and replace the result with the truth
        value of the trap (True if an exception occurred).

        First, give the decorator an alias to support Python 3.8
        Syntax.

        >>> raises = ExceptionTrap(ValueError).raises

        Now decorate a function that always fails.

        >>> @raises
        ... def fail():
        ...     raise ValueError('failed')
        >>> fail()
        True
        """

        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            with ExceptionTrap(self.exceptions) as trap:
                func(*args, **kwargs)
            return _test(trap)

        return wrapper

    def passes(self, func):
        """
        Wrap func and replace the result with the truth
        value of the trap (True if no exception).

        First, give the decorator an alias to support Python 3.8
        Syntax.

        >>> passes = ExceptionTrap(ValueError).passes

        Now decorate a function that always fails.

        >>> @passes
        ... def fail():
        ...     raise ValueError('failed')

        >>> fail()
        False
        """
        return self.raises(func, _test=operator.not_)


class suppress(contextlib.suppress, contextlib.ContextDecorator):
    """
    A version of contextlib.suppress with decorator support.

    >>> @suppress(KeyError)
    ... def key_error():
    ...     {}['']
    >>> key_error()
    """


class on_interrupt(contextlib.ContextDecorator):
    """
    Replace a KeyboardInterrupt with SystemExit(1)

    >>> def do_interrupt():
    ...     raise KeyboardInterrupt()
    >>> on_interrupt('error')(do_interrupt)()
    Traceback (most recent call last):
    ...
    SystemExit: 1
    >>> on_interrupt('error', code=255)(do_interrupt)()
    Traceback (most recent call last):
    ...
    SystemExit: 255
    >>> on_interrupt('suppress')(do_interrupt)()
    >>> with __import__('pytest').raises(KeyboardInterrupt):
    ...     on_interrupt('ignore')(do_interrupt)()
    """

    def __init__(
        self,
        action='error',
        # py3.7 compat
        # /,
        code=1,
    ):
        self.action = action
        self.code = code

    def __enter__(self):
        return self

    def __exit__(self, exctype, excinst, exctb):
        if exctype is not KeyboardInterrupt or self.action == 'ignore':
            return
        elif self.action == 'error':
            raise SystemExit(self.code) from excinst
        return self.action == 'suppress'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco/functools.py0000644000175100001730000003531514467657412023163 0ustar00runnerdockerimport functools
import time
import inspect
import collections
import types
import itertools
import warnings

import setuptools.extern.more_itertools

from typing import Callable, TypeVar


CallableT = TypeVar("CallableT", bound=Callable[..., object])


def compose(*funcs):
    """
    Compose any number of unary functions into a single unary function.

    >>> import textwrap
    >>> expected = str.strip(textwrap.dedent(compose.__doc__))
    >>> strip_and_dedent = compose(str.strip, textwrap.dedent)
    >>> strip_and_dedent(compose.__doc__) == expected
    True

    Compose also allows the innermost function to take arbitrary arguments.

    >>> round_three = lambda x: round(x, ndigits=3)
    >>> f = compose(round_three, int.__truediv__)
    >>> [f(3*x, x+1) for x in range(1,10)]
    [1.5, 2.0, 2.25, 2.4, 2.5, 2.571, 2.625, 2.667, 2.7]
    """

    def compose_two(f1, f2):
        return lambda *args, **kwargs: f1(f2(*args, **kwargs))

    return functools.reduce(compose_two, funcs)


def method_caller(method_name, *args, **kwargs):
    """
    Return a function that will call a named method on the
    target object with optional positional and keyword
    arguments.

    >>> lower = method_caller('lower')
    >>> lower('MyString')
    'mystring'
    """

    def call_method(target):
        func = getattr(target, method_name)
        return func(*args, **kwargs)

    return call_method


def once(func):
    """
    Decorate func so it's only ever called the first time.

    This decorator can ensure that an expensive or non-idempotent function
    will not be expensive on subsequent calls and is idempotent.

    >>> add_three = once(lambda a: a+3)
    >>> add_three(3)
    6
    >>> add_three(9)
    6
    >>> add_three('12')
    6

    To reset the stored value, simply clear the property ``saved_result``.

    >>> del add_three.saved_result
    >>> add_three(9)
    12
    >>> add_three(8)
    12

    Or invoke 'reset()' on it.

    >>> add_three.reset()
    >>> add_three(-3)
    0
    >>> add_three(0)
    0
    """

    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        if not hasattr(wrapper, 'saved_result'):
            wrapper.saved_result = func(*args, **kwargs)
        return wrapper.saved_result

    wrapper.reset = lambda: vars(wrapper).__delitem__('saved_result')
    return wrapper


def method_cache(
    method: CallableT,
    cache_wrapper: Callable[
        [CallableT], CallableT
    ] = functools.lru_cache(),  # type: ignore[assignment]
) -> CallableT:
    """
    Wrap lru_cache to support storing the cache data in the object instances.

    Abstracts the common paradigm where the method explicitly saves an
    underscore-prefixed protected property on first call and returns that
    subsequently.

    >>> class MyClass:
    ...     calls = 0
    ...
    ...     @method_cache
    ...     def method(self, value):
    ...         self.calls += 1
    ...         return value

    >>> a = MyClass()
    >>> a.method(3)
    3
    >>> for x in range(75):
    ...     res = a.method(x)
    >>> a.calls
    75

    Note that the apparent behavior will be exactly like that of lru_cache
    except that the cache is stored on each instance, so values in one
    instance will not flush values from another, and when an instance is
    deleted, so are the cached values for that instance.

    >>> b = MyClass()
    >>> for x in range(35):
    ...     res = b.method(x)
    >>> b.calls
    35
    >>> a.method(0)
    0
    >>> a.calls
    75

    Note that if method had been decorated with ``functools.lru_cache()``,
    a.calls would have been 76 (due to the cached value of 0 having been
    flushed by the 'b' instance).

    Clear the cache with ``.cache_clear()``

    >>> a.method.cache_clear()

    Same for a method that hasn't yet been called.

    >>> c = MyClass()
    >>> c.method.cache_clear()

    Another cache wrapper may be supplied:

    >>> cache = functools.lru_cache(maxsize=2)
    >>> MyClass.method2 = method_cache(lambda self: 3, cache_wrapper=cache)
    >>> a = MyClass()
    >>> a.method2()
    3

    Caution - do not subsequently wrap the method with another decorator, such
    as ``@property``, which changes the semantics of the function.

    See also
    http://code.activestate.com/recipes/577452-a-memoize-decorator-for-instance-methods/
    for another implementation and additional justification.
    """

    def wrapper(self: object, *args: object, **kwargs: object) -> object:
        # it's the first call, replace the method with a cached, bound method
        bound_method: CallableT = types.MethodType(  # type: ignore[assignment]
            method, self
        )
        cached_method = cache_wrapper(bound_method)
        setattr(self, method.__name__, cached_method)
        return cached_method(*args, **kwargs)

    # Support cache clear even before cache has been created.
    wrapper.cache_clear = lambda: None  # type: ignore[attr-defined]

    return (  # type: ignore[return-value]
        _special_method_cache(method, cache_wrapper) or wrapper
    )


def _special_method_cache(method, cache_wrapper):
    """
    Because Python treats special methods differently, it's not
    possible to use instance attributes to implement the cached
    methods.

    Instead, install the wrapper method under a different name
    and return a simple proxy to that wrapper.

    https://github.com/jaraco/jaraco.functools/issues/5
    """
    name = method.__name__
    special_names = '__getattr__', '__getitem__'
    if name not in special_names:
        return

    wrapper_name = '__cached' + name

    def proxy(self, *args, **kwargs):
        if wrapper_name not in vars(self):
            bound = types.MethodType(method, self)
            cache = cache_wrapper(bound)
            setattr(self, wrapper_name, cache)
        else:
            cache = getattr(self, wrapper_name)
        return cache(*args, **kwargs)

    return proxy


def apply(transform):
    """
    Decorate a function with a transform function that is
    invoked on results returned from the decorated function.

    >>> @apply(reversed)
    ... def get_numbers(start):
    ...     "doc for get_numbers"
    ...     return range(start, start+3)
    >>> list(get_numbers(4))
    [6, 5, 4]
    >>> get_numbers.__doc__
    'doc for get_numbers'
    """

    def wrap(func):
        return functools.wraps(func)(compose(transform, func))

    return wrap


def result_invoke(action):
    r"""
    Decorate a function with an action function that is
    invoked on the results returned from the decorated
    function (for its side-effect), then return the original
    result.

    >>> @result_invoke(print)
    ... def add_two(a, b):
    ...     return a + b
    >>> x = add_two(2, 3)
    5
    >>> x
    5
    """

    def wrap(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            result = func(*args, **kwargs)
            action(result)
            return result

        return wrapper

    return wrap


def invoke(f, *args, **kwargs):
    """
    Call a function for its side effect after initialization.

    The benefit of using the decorator instead of simply invoking a function
    after defining it is that it makes explicit the author's intent for the
    function to be called immediately. Whereas if one simply calls the
    function immediately, it's less obvious if that was intentional or
    incidental. It also avoids repeating the name - the two actions, defining
    the function and calling it immediately are modeled separately, but linked
    by the decorator construct.

    The benefit of having a function construct (opposed to just invoking some
    behavior inline) is to serve as a scope in which the behavior occurs. It
    avoids polluting the global namespace with local variables, provides an
    anchor on which to attach documentation (docstring), keeps the behavior
    logically separated (instead of conceptually separated or not separated at
    all), and provides potential to re-use the behavior for testing or other
    purposes.

    This function is named as a pithy way to communicate, "call this function
    primarily for its side effect", or "while defining this function, also
    take it aside and call it". It exists because there's no Python construct
    for "define and call" (nor should there be, as decorators serve this need
    just fine). The behavior happens immediately and synchronously.

    >>> @invoke
    ... def func(): print("called")
    called
    >>> func()
    called

    Use functools.partial to pass parameters to the initial call

    >>> @functools.partial(invoke, name='bingo')
    ... def func(name): print("called with", name)
    called with bingo
    """
    f(*args, **kwargs)
    return f


def call_aside(*args, **kwargs):
    """
    Deprecated name for invoke.
    """
    warnings.warn("call_aside is deprecated, use invoke", DeprecationWarning)
    return invoke(*args, **kwargs)


class Throttler:
    """
    Rate-limit a function (or other callable)
    """

    def __init__(self, func, max_rate=float('Inf')):
        if isinstance(func, Throttler):
            func = func.func
        self.func = func
        self.max_rate = max_rate
        self.reset()

    def reset(self):
        self.last_called = 0

    def __call__(self, *args, **kwargs):
        self._wait()
        return self.func(*args, **kwargs)

    def _wait(self):
        "ensure at least 1/max_rate seconds from last call"
        elapsed = time.time() - self.last_called
        must_wait = 1 / self.max_rate - elapsed
        time.sleep(max(0, must_wait))
        self.last_called = time.time()

    def __get__(self, obj, type=None):
        return first_invoke(self._wait, functools.partial(self.func, obj))


def first_invoke(func1, func2):
    """
    Return a function that when invoked will invoke func1 without
    any parameters (for its side-effect) and then invoke func2
    with whatever parameters were passed, returning its result.
    """

    def wrapper(*args, **kwargs):
        func1()
        return func2(*args, **kwargs)

    return wrapper


def retry_call(func, cleanup=lambda: None, retries=0, trap=()):
    """
    Given a callable func, trap the indicated exceptions
    for up to 'retries' times, invoking cleanup on the
    exception. On the final attempt, allow any exceptions
    to propagate.
    """
    attempts = itertools.count() if retries == float('inf') else range(retries)
    for attempt in attempts:
        try:
            return func()
        except trap:
            cleanup()

    return func()


def retry(*r_args, **r_kwargs):
    """
    Decorator wrapper for retry_call. Accepts arguments to retry_call
    except func and then returns a decorator for the decorated function.

    Ex:

    >>> @retry(retries=3)
    ... def my_func(a, b):
    ...     "this is my funk"
    ...     print(a, b)
    >>> my_func.__doc__
    'this is my funk'
    """

    def decorate(func):
        @functools.wraps(func)
        def wrapper(*f_args, **f_kwargs):
            bound = functools.partial(func, *f_args, **f_kwargs)
            return retry_call(bound, *r_args, **r_kwargs)

        return wrapper

    return decorate


def print_yielded(func):
    """
    Convert a generator into a function that prints all yielded elements

    >>> @print_yielded
    ... def x():
    ...     yield 3; yield None
    >>> x()
    3
    None
    """
    print_all = functools.partial(map, print)
    print_results = compose(more_itertools.consume, print_all, func)
    return functools.wraps(func)(print_results)


def pass_none(func):
    """
    Wrap func so it's not called if its first param is None

    >>> print_text = pass_none(print)
    >>> print_text('text')
    text
    >>> print_text(None)
    """

    @functools.wraps(func)
    def wrapper(param, *args, **kwargs):
        if param is not None:
            return func(param, *args, **kwargs)

    return wrapper


def assign_params(func, namespace):
    """
    Assign parameters from namespace where func solicits.

    >>> def func(x, y=3):
    ...     print(x, y)
    >>> assigned = assign_params(func, dict(x=2, z=4))
    >>> assigned()
    2 3

    The usual errors are raised if a function doesn't receive
    its required parameters:

    >>> assigned = assign_params(func, dict(y=3, z=4))
    >>> assigned()
    Traceback (most recent call last):
    TypeError: func() ...argument...

    It even works on methods:

    >>> class Handler:
    ...     def meth(self, arg):
    ...         print(arg)
    >>> assign_params(Handler().meth, dict(arg='crystal', foo='clear'))()
    crystal
    """
    sig = inspect.signature(func)
    params = sig.parameters.keys()
    call_ns = {k: namespace[k] for k in params if k in namespace}
    return functools.partial(func, **call_ns)


def save_method_args(method):
    """
    Wrap a method such that when it is called, the args and kwargs are
    saved on the method.

    >>> class MyClass:
    ...     @save_method_args
    ...     def method(self, a, b):
    ...         print(a, b)
    >>> my_ob = MyClass()
    >>> my_ob.method(1, 2)
    1 2
    >>> my_ob._saved_method.args
    (1, 2)
    >>> my_ob._saved_method.kwargs
    {}
    >>> my_ob.method(a=3, b='foo')
    3 foo
    >>> my_ob._saved_method.args
    ()
    >>> my_ob._saved_method.kwargs == dict(a=3, b='foo')
    True

    The arguments are stored on the instance, allowing for
    different instance to save different args.

    >>> your_ob = MyClass()
    >>> your_ob.method({str('x'): 3}, b=[4])
    {'x': 3} [4]
    >>> your_ob._saved_method.args
    ({'x': 3},)
    >>> my_ob._saved_method.args
    ()
    """
    args_and_kwargs = collections.namedtuple('args_and_kwargs', 'args kwargs')

    @functools.wraps(method)
    def wrapper(self, *args, **kwargs):
        attr_name = '_saved_' + method.__name__
        attr = args_and_kwargs(args, kwargs)
        setattr(self, attr_name, attr)
        return method(self, *args, **kwargs)

    return wrapper


def except_(*exceptions, replace=None, use=None):
    """
    Replace the indicated exceptions, if raised, with the indicated
    literal replacement or evaluated expression (if present).

    >>> safe_int = except_(ValueError)(int)
    >>> safe_int('five')
    >>> safe_int('5')
    5

    Specify a literal replacement with ``replace``.

    >>> safe_int_r = except_(ValueError, replace=0)(int)
    >>> safe_int_r('five')
    0

    Provide an expression to ``use`` to pass through particular parameters.

    >>> safe_int_pt = except_(ValueError, use='args[0]')(int)
    >>> safe_int_pt('five')
    'five'

    """

    def decorate(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            try:
                return func(*args, **kwargs)
            except exceptions:
                try:
                    return eval(use)
                except TypeError:
                    return replace

        return wrapper

    return decorate
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/jaraco/text/0000755000175100001730000000000014467657444021557 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco/text/Lorem ipsum.txt0000644000175100001730000000246714467657412024520 0ustar00runnerdockerLorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam varius, turpis et commodo pharetra, est eros bibendum elit, nec luctus magna felis sollicitudin mauris. Integer in mauris eu nibh euismod gravida. Duis ac tellus et risus vulputate vehicula. Donec lobortis risus a elit. Etiam tempor. Ut ullamcorper, ligula eu tempor congue, eros est euismod turpis, id tincidunt sapien risus a quam. Maecenas fermentum consequat mi. Donec fermentum. Pellentesque malesuada nulla a mi. Duis sapien sem, aliquet nec, commodo eget, consequat quis, neque. Aliquam faucibus, elit ut dictum aliquet, felis nisl adipiscing sapien, sed malesuada diam lacus eget erat. Cras mollis scelerisque nunc. Nullam arcu. Aliquam consequat. Curabitur augue lorem, dapibus quis, laoreet et, pretium ac, nisi. Aenean magna nisl, mollis quis, molestie eu, feugiat in, orci. In hac habitasse platea dictumst.
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco/text/__init__.py0000644000175100001730000003623514467657412023674 0ustar00runnerdockerimport re
import itertools
import textwrap
import functools

try:
    from importlib.resources import files  # type: ignore
except ImportError:  # pragma: nocover
    from setuptools.extern.importlib_resources import files  # type: ignore

from setuptools.extern.jaraco.functools import compose, method_cache
from setuptools.extern.jaraco.context import ExceptionTrap


def substitution(old, new):
    """
    Return a function that will perform a substitution on a string
    """
    return lambda s: s.replace(old, new)


def multi_substitution(*substitutions):
    """
    Take a sequence of pairs specifying substitutions, and create
    a function that performs those substitutions.

    >>> multi_substitution(('foo', 'bar'), ('bar', 'baz'))('foo')
    'baz'
    """
    substitutions = itertools.starmap(substitution, substitutions)
    # compose function applies last function first, so reverse the
    #  substitutions to get the expected order.
    substitutions = reversed(tuple(substitutions))
    return compose(*substitutions)


class FoldedCase(str):
    """
    A case insensitive string class; behaves just like str
    except compares equal when the only variation is case.

    >>> s = FoldedCase('hello world')

    >>> s == 'Hello World'
    True

    >>> 'Hello World' == s
    True

    >>> s != 'Hello World'
    False

    >>> s.index('O')
    4

    >>> s.split('O')
    ['hell', ' w', 'rld']

    >>> sorted(map(FoldedCase, ['GAMMA', 'alpha', 'Beta']))
    ['alpha', 'Beta', 'GAMMA']

    Sequence membership is straightforward.

    >>> "Hello World" in [s]
    True
    >>> s in ["Hello World"]
    True

    You may test for set inclusion, but candidate and elements
    must both be folded.

    >>> FoldedCase("Hello World") in {s}
    True
    >>> s in {FoldedCase("Hello World")}
    True

    String inclusion works as long as the FoldedCase object
    is on the right.

    >>> "hello" in FoldedCase("Hello World")
    True

    But not if the FoldedCase object is on the left:

    >>> FoldedCase('hello') in 'Hello World'
    False

    In that case, use ``in_``:

    >>> FoldedCase('hello').in_('Hello World')
    True

    >>> FoldedCase('hello') > FoldedCase('Hello')
    False
    """

    def __lt__(self, other):
        return self.lower() < other.lower()

    def __gt__(self, other):
        return self.lower() > other.lower()

    def __eq__(self, other):
        return self.lower() == other.lower()

    def __ne__(self, other):
        return self.lower() != other.lower()

    def __hash__(self):
        return hash(self.lower())

    def __contains__(self, other):
        return super().lower().__contains__(other.lower())

    def in_(self, other):
        "Does self appear in other?"
        return self in FoldedCase(other)

    # cache lower since it's likely to be called frequently.
    @method_cache
    def lower(self):
        return super().lower()

    def index(self, sub):
        return self.lower().index(sub.lower())

    def split(self, splitter=' ', maxsplit=0):
        pattern = re.compile(re.escape(splitter), re.I)
        return pattern.split(self, maxsplit)


# Python 3.8 compatibility
_unicode_trap = ExceptionTrap(UnicodeDecodeError)


@_unicode_trap.passes
def is_decodable(value):
    r"""
    Return True if the supplied value is decodable (using the default
    encoding).

    >>> is_decodable(b'\xff')
    False
    >>> is_decodable(b'\x32')
    True
    """
    value.decode()


def is_binary(value):
    r"""
    Return True if the value appears to be binary (that is, it's a byte
    string and isn't decodable).

    >>> is_binary(b'\xff')
    True
    >>> is_binary('\xff')
    False
    """
    return isinstance(value, bytes) and not is_decodable(value)


def trim(s):
    r"""
    Trim something like a docstring to remove the whitespace that
    is common due to indentation and formatting.

    >>> trim("\n\tfoo = bar\n\t\tbar = baz\n")
    'foo = bar\n\tbar = baz'
    """
    return textwrap.dedent(s).strip()


def wrap(s):
    """
    Wrap lines of text, retaining existing newlines as
    paragraph markers.

    >>> print(wrap(lorem_ipsum))
    Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do
    eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad
    minim veniam, quis nostrud exercitation ullamco laboris nisi ut
    aliquip ex ea commodo consequat. Duis aute irure dolor in
    reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla
    pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
    culpa qui officia deserunt mollit anim id est laborum.
    
    Curabitur pretium tincidunt lacus. Nulla gravida orci a odio. Nullam
    varius, turpis et commodo pharetra, est eros bibendum elit, nec luctus
    magna felis sollicitudin mauris. Integer in mauris eu nibh euismod
    gravida. Duis ac tellus et risus vulputate vehicula. Donec lobortis
    risus a elit. Etiam tempor. Ut ullamcorper, ligula eu tempor congue,
    eros est euismod turpis, id tincidunt sapien risus a quam. Maecenas
    fermentum consequat mi. Donec fermentum. Pellentesque malesuada nulla
    a mi. Duis sapien sem, aliquet nec, commodo eget, consequat quis,
    neque. Aliquam faucibus, elit ut dictum aliquet, felis nisl adipiscing
    sapien, sed malesuada diam lacus eget erat. Cras mollis scelerisque
    nunc. Nullam arcu. Aliquam consequat. Curabitur augue lorem, dapibus
    quis, laoreet et, pretium ac, nisi. Aenean magna nisl, mollis quis,
    molestie eu, feugiat in, orci. In hac habitasse platea dictumst.
    """
    paragraphs = s.splitlines()
    wrapped = ('\n'.join(textwrap.wrap(para)) for para in paragraphs)
    return '\n\n'.join(wrapped)


def unwrap(s):
    r"""
    Given a multi-line string, return an unwrapped version.

    >>> wrapped = wrap(lorem_ipsum)
    >>> wrapped.count('\n')
    20
    >>> unwrapped = unwrap(wrapped)
    >>> unwrapped.count('\n')
    1
    >>> print(unwrapped)
    Lorem ipsum dolor sit amet, consectetur adipiscing ...
    Curabitur pretium tincidunt lacus. Nulla gravida orci ...

    """
    paragraphs = re.split(r'\n\n+', s)
    cleaned = (para.replace('\n', ' ') for para in paragraphs)
    return '\n'.join(cleaned)




class Splitter(object):
    """object that will split a string with the given arguments for each call

    >>> s = Splitter(',')
    >>> s('hello, world, this is your, master calling')
    ['hello', ' world', ' this is your', ' master calling']
    """

    def __init__(self, *args):
        self.args = args

    def __call__(self, s):
        return s.split(*self.args)


def indent(string, prefix=' ' * 4):
    """
    >>> indent('foo')
    '    foo'
    """
    return prefix + string


class WordSet(tuple):
    """
    Given an identifier, return the words that identifier represents,
    whether in camel case, underscore-separated, etc.

    >>> WordSet.parse("camelCase")
    ('camel', 'Case')

    >>> WordSet.parse("under_sep")
    ('under', 'sep')

    Acronyms should be retained

    >>> WordSet.parse("firstSNL")
    ('first', 'SNL')

    >>> WordSet.parse("you_and_I")
    ('you', 'and', 'I')

    >>> WordSet.parse("A simple test")
    ('A', 'simple', 'test')

    Multiple caps should not interfere with the first cap of another word.

    >>> WordSet.parse("myABCClass")
    ('my', 'ABC', 'Class')

    The result is a WordSet, so you can get the form you need.

    >>> WordSet.parse("myABCClass").underscore_separated()
    'my_ABC_Class'

    >>> WordSet.parse('a-command').camel_case()
    'ACommand'

    >>> WordSet.parse('someIdentifier').lowered().space_separated()
    'some identifier'

    Slices of the result should return another WordSet.

    >>> WordSet.parse('taken-out-of-context')[1:].underscore_separated()
    'out_of_context'

    >>> WordSet.from_class_name(WordSet()).lowered().space_separated()
    'word set'

    >>> example = WordSet.parse('figured it out')
    >>> example.headless_camel_case()
    'figuredItOut'
    >>> example.dash_separated()
    'figured-it-out'

    """

    _pattern = re.compile('([A-Z]?[a-z]+)|([A-Z]+(?![a-z]))')

    def capitalized(self):
        return WordSet(word.capitalize() for word in self)

    def lowered(self):
        return WordSet(word.lower() for word in self)

    def camel_case(self):
        return ''.join(self.capitalized())

    def headless_camel_case(self):
        words = iter(self)
        first = next(words).lower()
        new_words = itertools.chain((first,), WordSet(words).camel_case())
        return ''.join(new_words)

    def underscore_separated(self):
        return '_'.join(self)

    def dash_separated(self):
        return '-'.join(self)

    def space_separated(self):
        return ' '.join(self)

    def trim_right(self, item):
        """
        Remove the item from the end of the set.

        >>> WordSet.parse('foo bar').trim_right('foo')
        ('foo', 'bar')
        >>> WordSet.parse('foo bar').trim_right('bar')
        ('foo',)
        >>> WordSet.parse('').trim_right('bar')
        ()
        """
        return self[:-1] if self and self[-1] == item else self

    def trim_left(self, item):
        """
        Remove the item from the beginning of the set.

        >>> WordSet.parse('foo bar').trim_left('foo')
        ('bar',)
        >>> WordSet.parse('foo bar').trim_left('bar')
        ('foo', 'bar')
        >>> WordSet.parse('').trim_left('bar')
        ()
        """
        return self[1:] if self and self[0] == item else self

    def trim(self, item):
        """
        >>> WordSet.parse('foo bar').trim('foo')
        ('bar',)
        """
        return self.trim_left(item).trim_right(item)

    def __getitem__(self, item):
        result = super(WordSet, self).__getitem__(item)
        if isinstance(item, slice):
            result = WordSet(result)
        return result

    @classmethod
    def parse(cls, identifier):
        matches = cls._pattern.finditer(identifier)
        return WordSet(match.group(0) for match in matches)

    @classmethod
    def from_class_name(cls, subject):
        return cls.parse(subject.__class__.__name__)


# for backward compatibility
words = WordSet.parse


def simple_html_strip(s):
    r"""
    Remove HTML from the string `s`.

    >>> str(simple_html_strip(''))
    ''

    >>> print(simple_html_strip('A stormy day in paradise'))
    A stormy day in paradise

    >>> print(simple_html_strip('Somebody  tell the truth.'))
    Somebody  tell the truth.

    >>> print(simple_html_strip('What about
\nmultiple lines?'))
    What about
    multiple lines?
    """
    html_stripper = re.compile('()|(<[^>]*>)|([^<]+)', re.DOTALL)
    texts = (match.group(3) or '' for match in html_stripper.finditer(s))
    return ''.join(texts)


class SeparatedValues(str):
    """
    A string separated by a separator. Overrides __iter__ for getting
    the values.

    >>> list(SeparatedValues('a,b,c'))
    ['a', 'b', 'c']

    Whitespace is stripped and empty values are discarded.

    >>> list(SeparatedValues(' a,   b   , c,  '))
    ['a', 'b', 'c']
    """

    separator = ','

    def __iter__(self):
        parts = self.split(self.separator)
        return filter(None, (part.strip() for part in parts))


class Stripper:
    r"""
    Given a series of lines, find the common prefix and strip it from them.

    >>> lines = [
    ...     'abcdefg\n',
    ...     'abc\n',
    ...     'abcde\n',
    ... ]
    >>> res = Stripper.strip_prefix(lines)
    >>> res.prefix
    'abc'
    >>> list(res.lines)
    ['defg\n', '\n', 'de\n']

    If no prefix is common, nothing should be stripped.

    >>> lines = [
    ...     'abcd\n',
    ...     '1234\n',
    ... ]
    >>> res = Stripper.strip_prefix(lines)
    >>> res.prefix = ''
    >>> list(res.lines)
    ['abcd\n', '1234\n']
    """

    def __init__(self, prefix, lines):
        self.prefix = prefix
        self.lines = map(self, lines)

    @classmethod
    def strip_prefix(cls, lines):
        prefix_lines, lines = itertools.tee(lines)
        prefix = functools.reduce(cls.common_prefix, prefix_lines)
        return cls(prefix, lines)

    def __call__(self, line):
        if not self.prefix:
            return line
        null, prefix, rest = line.partition(self.prefix)
        return rest

    @staticmethod
    def common_prefix(s1, s2):
        """
        Return the common prefix of two lines.
        """
        index = min(len(s1), len(s2))
        while s1[:index] != s2[:index]:
            index -= 1
        return s1[:index]


def remove_prefix(text, prefix):
    """
    Remove the prefix from the text if it exists.

    >>> remove_prefix('underwhelming performance', 'underwhelming ')
    'performance'

    >>> remove_prefix('something special', 'sample')
    'something special'
    """
    null, prefix, rest = text.rpartition(prefix)
    return rest


def remove_suffix(text, suffix):
    """
    Remove the suffix from the text if it exists.

    >>> remove_suffix('name.git', '.git')
    'name'

    >>> remove_suffix('something special', 'sample')
    'something special'
    """
    rest, suffix, null = text.partition(suffix)
    return rest


def normalize_newlines(text):
    r"""
    Replace alternate newlines with the canonical newline.

    >>> normalize_newlines('Lorem Ipsum\u2029')
    'Lorem Ipsum\n'
    >>> normalize_newlines('Lorem Ipsum\r\n')
    'Lorem Ipsum\n'
    >>> normalize_newlines('Lorem Ipsum\x85')
    'Lorem Ipsum\n'
    """
    newlines = ['\r\n', '\r', '\n', '\u0085', '\u2028', '\u2029']
    pattern = '|'.join(newlines)
    return re.sub(pattern, '\n', text)


def _nonblank(str):
    return str and not str.startswith('#')


@functools.singledispatch
def yield_lines(iterable):
    r"""
    Yield valid lines of a string or iterable.

    >>> list(yield_lines(''))
    []
    >>> list(yield_lines(['foo', 'bar']))
    ['foo', 'bar']
    >>> list(yield_lines('foo\nbar'))
    ['foo', 'bar']
    >>> list(yield_lines('\nfoo\n#bar\nbaz #comment'))
    ['foo', 'baz #comment']
    >>> list(yield_lines(['foo\nbar', 'baz', 'bing\n\n\n']))
    ['foo', 'bar', 'baz', 'bing']
    """
    return itertools.chain.from_iterable(map(yield_lines, iterable))


@yield_lines.register(str)
def _(text):
    return filter(_nonblank, map(str.strip, text.splitlines()))


def drop_comment(line):
    """
    Drop comments.

    >>> drop_comment('foo # bar')
    'foo'

    A hash without a space may be in a URL.

    >>> drop_comment('http://example.com/foo#bar')
    'http://example.com/foo#bar'
    """
    return line.partition(' #')[0]


def join_continuation(lines):
    r"""
    Join lines continued by a trailing backslash.

    >>> list(join_continuation(['foo \\', 'bar', 'baz']))
    ['foobar', 'baz']
    >>> list(join_continuation(['foo \\', 'bar', 'baz']))
    ['foobar', 'baz']
    >>> list(join_continuation(['foo \\', 'bar \\', 'baz']))
    ['foobarbaz']

    Not sure why, but...
    The character preceeding the backslash is also elided.

    >>> list(join_continuation(['goo\\', 'dly']))
    ['godly']

    A terrible idea, but...
    If no line is available to continue, suppress the lines.

    >>> list(join_continuation(['foo', 'bar\\', 'baz\\']))
    ['foo']
    """
    lines = iter(lines)
    for item in lines:
        while item.endswith('\\'):
            try:
                item = item[:-2].strip() + next(lines)
            except StopIteration:
                return
        yield item
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/jaraco.context-4.3.0.dist-info/0000755000175100001730000000000014467657444024611 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco.context-4.3.0.dist-info/top_level.txt0000644000175100001730000000000714467657412027333 0ustar00runnerdockerjaraco
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5315502
setuptools-68.1.2/setuptools/_vendor/jaraco.functools-3.6.0.dist-info/0000755000175100001730000000000014467657444025143 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco.functools-3.6.0.dist-info/top_level.txt0000644000175100001730000000000714467657412027665 0ustar00runnerdockerjaraco
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/jaraco.text-3.7.0.dist-info/0000755000175100001730000000000014467657444024114 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/jaraco.text-3.7.0.dist-info/top_level.txt0000644000175100001730000000000714467657412026636 0ustar00runnerdockerjaraco
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/more_itertools/0000755000175100001730000000000014467657444022402 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/more_itertools/__init__.py0000644000175100001730000000012214467657412024501 0ustar00runnerdockerfrom .more import *  # noqa
from .recipes import *  # noqa

__version__ = '8.8.0'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/more_itertools/more.py0000644000175100001730000034630714467657412023726 0ustar00runnerdockerimport warnings

from collections import Counter, defaultdict, deque, abc
from collections.abc import Sequence
from functools import partial, reduce, wraps
from heapq import merge, heapify, heapreplace, heappop
from itertools import (
    chain,
    compress,
    count,
    cycle,
    dropwhile,
    groupby,
    islice,
    repeat,
    starmap,
    takewhile,
    tee,
    zip_longest,
)
from math import exp, factorial, floor, log
from queue import Empty, Queue
from random import random, randrange, uniform
from operator import itemgetter, mul, sub, gt, lt
from sys import hexversion, maxsize
from time import monotonic

from .recipes import (
    consume,
    flatten,
    pairwise,
    powerset,
    take,
    unique_everseen,
)

__all__ = [
    'AbortThread',
    'adjacent',
    'always_iterable',
    'always_reversible',
    'bucket',
    'callback_iter',
    'chunked',
    'circular_shifts',
    'collapse',
    'collate',
    'consecutive_groups',
    'consumer',
    'countable',
    'count_cycle',
    'mark_ends',
    'difference',
    'distinct_combinations',
    'distinct_permutations',
    'distribute',
    'divide',
    'exactly_n',
    'filter_except',
    'first',
    'groupby_transform',
    'ilen',
    'interleave_longest',
    'interleave',
    'intersperse',
    'islice_extended',
    'iterate',
    'ichunked',
    'is_sorted',
    'last',
    'locate',
    'lstrip',
    'make_decorator',
    'map_except',
    'map_reduce',
    'nth_or_last',
    'nth_permutation',
    'nth_product',
    'numeric_range',
    'one',
    'only',
    'padded',
    'partitions',
    'set_partitions',
    'peekable',
    'repeat_last',
    'replace',
    'rlocate',
    'rstrip',
    'run_length',
    'sample',
    'seekable',
    'SequenceView',
    'side_effect',
    'sliced',
    'sort_together',
    'split_at',
    'split_after',
    'split_before',
    'split_when',
    'split_into',
    'spy',
    'stagger',
    'strip',
    'substrings',
    'substrings_indexes',
    'time_limited',
    'unique_to_each',
    'unzip',
    'windowed',
    'with_iter',
    'UnequalIterablesError',
    'zip_equal',
    'zip_offset',
    'windowed_complete',
    'all_unique',
    'value_chain',
    'product_index',
    'combination_index',
    'permutation_index',
]

_marker = object()


def chunked(iterable, n, strict=False):
    """Break *iterable* into lists of length *n*:

        >>> list(chunked([1, 2, 3, 4, 5, 6], 3))
        [[1, 2, 3], [4, 5, 6]]

    By the default, the last yielded list will have fewer than *n* elements
    if the length of *iterable* is not divisible by *n*:

        >>> list(chunked([1, 2, 3, 4, 5, 6, 7, 8], 3))
        [[1, 2, 3], [4, 5, 6], [7, 8]]

    To use a fill-in value instead, see the :func:`grouper` recipe.

    If the length of *iterable* is not divisible by *n* and *strict* is
    ``True``, then ``ValueError`` will be raised before the last
    list is yielded.

    """
    iterator = iter(partial(take, n, iter(iterable)), [])
    if strict:

        def ret():
            for chunk in iterator:
                if len(chunk) != n:
                    raise ValueError('iterable is not divisible by n.')
                yield chunk

        return iter(ret())
    else:
        return iterator


def first(iterable, default=_marker):
    """Return the first item of *iterable*, or *default* if *iterable* is
    empty.

        >>> first([0, 1, 2, 3])
        0
        >>> first([], 'some default')
        'some default'

    If *default* is not provided and there are no items in the iterable,
    raise ``ValueError``.

    :func:`first` is useful when you have a generator of expensive-to-retrieve
    values and want any arbitrary one. It is marginally shorter than
    ``next(iter(iterable), default)``.

    """
    try:
        return next(iter(iterable))
    except StopIteration as e:
        if default is _marker:
            raise ValueError(
                'first() was called on an empty iterable, and no '
                'default value was provided.'
            ) from e
        return default


def last(iterable, default=_marker):
    """Return the last item of *iterable*, or *default* if *iterable* is
    empty.

        >>> last([0, 1, 2, 3])
        3
        >>> last([], 'some default')
        'some default'

    If *default* is not provided and there are no items in the iterable,
    raise ``ValueError``.
    """
    try:
        if isinstance(iterable, Sequence):
            return iterable[-1]
        # Work around https://bugs.python.org/issue38525
        elif hasattr(iterable, '__reversed__') and (hexversion != 0x030800F0):
            return next(reversed(iterable))
        else:
            return deque(iterable, maxlen=1)[-1]
    except (IndexError, TypeError, StopIteration):
        if default is _marker:
            raise ValueError(
                'last() was called on an empty iterable, and no default was '
                'provided.'
            )
        return default


def nth_or_last(iterable, n, default=_marker):
    """Return the nth or the last item of *iterable*,
    or *default* if *iterable* is empty.

        >>> nth_or_last([0, 1, 2, 3], 2)
        2
        >>> nth_or_last([0, 1], 2)
        1
        >>> nth_or_last([], 0, 'some default')
        'some default'

    If *default* is not provided and there are no items in the iterable,
    raise ``ValueError``.
    """
    return last(islice(iterable, n + 1), default=default)


class peekable:
    """Wrap an iterator to allow lookahead and prepending elements.

    Call :meth:`peek` on the result to get the value that will be returned
    by :func:`next`. This won't advance the iterator:

        >>> p = peekable(['a', 'b'])
        >>> p.peek()
        'a'
        >>> next(p)
        'a'

    Pass :meth:`peek` a default value to return that instead of raising
    ``StopIteration`` when the iterator is exhausted.

        >>> p = peekable([])
        >>> p.peek('hi')
        'hi'

    peekables also offer a :meth:`prepend` method, which "inserts" items
    at the head of the iterable:

        >>> p = peekable([1, 2, 3])
        >>> p.prepend(10, 11, 12)
        >>> next(p)
        10
        >>> p.peek()
        11
        >>> list(p)
        [11, 12, 1, 2, 3]

    peekables can be indexed. Index 0 is the item that will be returned by
    :func:`next`, index 1 is the item after that, and so on:
    The values up to the given index will be cached.

        >>> p = peekable(['a', 'b', 'c', 'd'])
        >>> p[0]
        'a'
        >>> p[1]
        'b'
        >>> next(p)
        'a'

    Negative indexes are supported, but be aware that they will cache the
    remaining items in the source iterator, which may require significant
    storage.

    To check whether a peekable is exhausted, check its truth value:

        >>> p = peekable(['a', 'b'])
        >>> if p:  # peekable has items
        ...     list(p)
        ['a', 'b']
        >>> if not p:  # peekable is exhausted
        ...     list(p)
        []

    """

    def __init__(self, iterable):
        self._it = iter(iterable)
        self._cache = deque()

    def __iter__(self):
        return self

    def __bool__(self):
        try:
            self.peek()
        except StopIteration:
            return False
        return True

    def peek(self, default=_marker):
        """Return the item that will be next returned from ``next()``.

        Return ``default`` if there are no items left. If ``default`` is not
        provided, raise ``StopIteration``.

        """
        if not self._cache:
            try:
                self._cache.append(next(self._it))
            except StopIteration:
                if default is _marker:
                    raise
                return default
        return self._cache[0]

    def prepend(self, *items):
        """Stack up items to be the next ones returned from ``next()`` or
        ``self.peek()``. The items will be returned in
        first in, first out order::

            >>> p = peekable([1, 2, 3])
            >>> p.prepend(10, 11, 12)
            >>> next(p)
            10
            >>> list(p)
            [11, 12, 1, 2, 3]

        It is possible, by prepending items, to "resurrect" a peekable that
        previously raised ``StopIteration``.

            >>> p = peekable([])
            >>> next(p)
            Traceback (most recent call last):
              ...
            StopIteration
            >>> p.prepend(1)
            >>> next(p)
            1
            >>> next(p)
            Traceback (most recent call last):
              ...
            StopIteration

        """
        self._cache.extendleft(reversed(items))

    def __next__(self):
        if self._cache:
            return self._cache.popleft()

        return next(self._it)

    def _get_slice(self, index):
        # Normalize the slice's arguments
        step = 1 if (index.step is None) else index.step
        if step > 0:
            start = 0 if (index.start is None) else index.start
            stop = maxsize if (index.stop is None) else index.stop
        elif step < 0:
            start = -1 if (index.start is None) else index.start
            stop = (-maxsize - 1) if (index.stop is None) else index.stop
        else:
            raise ValueError('slice step cannot be zero')

        # If either the start or stop index is negative, we'll need to cache
        # the rest of the iterable in order to slice from the right side.
        if (start < 0) or (stop < 0):
            self._cache.extend(self._it)
        # Otherwise we'll need to find the rightmost index and cache to that
        # point.
        else:
            n = min(max(start, stop) + 1, maxsize)
            cache_len = len(self._cache)
            if n >= cache_len:
                self._cache.extend(islice(self._it, n - cache_len))

        return list(self._cache)[index]

    def __getitem__(self, index):
        if isinstance(index, slice):
            return self._get_slice(index)

        cache_len = len(self._cache)
        if index < 0:
            self._cache.extend(self._it)
        elif index >= cache_len:
            self._cache.extend(islice(self._it, index + 1 - cache_len))

        return self._cache[index]


def collate(*iterables, **kwargs):
    """Return a sorted merge of the items from each of several already-sorted
    *iterables*.

        >>> list(collate('ACDZ', 'AZ', 'JKL'))
        ['A', 'A', 'C', 'D', 'J', 'K', 'L', 'Z', 'Z']

    Works lazily, keeping only the next value from each iterable in memory. Use
    :func:`collate` to, for example, perform a n-way mergesort of items that
    don't fit in memory.

    If a *key* function is specified, the iterables will be sorted according
    to its result:

        >>> key = lambda s: int(s)  # Sort by numeric value, not by string
        >>> list(collate(['1', '10'], ['2', '11'], key=key))
        ['1', '2', '10', '11']


    If the *iterables* are sorted in descending order, set *reverse* to
    ``True``:

        >>> list(collate([5, 3, 1], [4, 2, 0], reverse=True))
        [5, 4, 3, 2, 1, 0]

    If the elements of the passed-in iterables are out of order, you might get
    unexpected results.

    On Python 3.5+, this function is an alias for :func:`heapq.merge`.

    """
    warnings.warn(
        "collate is no longer part of more_itertools, use heapq.merge",
        DeprecationWarning,
    )
    return merge(*iterables, **kwargs)


def consumer(func):
    """Decorator that automatically advances a PEP-342-style "reverse iterator"
    to its first yield point so you don't have to call ``next()`` on it
    manually.

        >>> @consumer
        ... def tally():
        ...     i = 0
        ...     while True:
        ...         print('Thing number %s is %s.' % (i, (yield)))
        ...         i += 1
        ...
        >>> t = tally()
        >>> t.send('red')
        Thing number 0 is red.
        >>> t.send('fish')
        Thing number 1 is fish.

    Without the decorator, you would have to call ``next(t)`` before
    ``t.send()`` could be used.

    """

    @wraps(func)
    def wrapper(*args, **kwargs):
        gen = func(*args, **kwargs)
        next(gen)
        return gen

    return wrapper


def ilen(iterable):
    """Return the number of items in *iterable*.

        >>> ilen(x for x in range(1000000) if x % 3 == 0)
        333334

    This consumes the iterable, so handle with care.

    """
    # This approach was selected because benchmarks showed it's likely the
    # fastest of the known implementations at the time of writing.
    # See GitHub tracker: #236, #230.
    counter = count()
    deque(zip(iterable, counter), maxlen=0)
    return next(counter)


def iterate(func, start):
    """Return ``start``, ``func(start)``, ``func(func(start))``, ...

    >>> from itertools import islice
    >>> list(islice(iterate(lambda x: 2*x, 1), 10))
    [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]

    """
    while True:
        yield start
        start = func(start)


def with_iter(context_manager):
    """Wrap an iterable in a ``with`` statement, so it closes once exhausted.

    For example, this will close the file when the iterator is exhausted::

        upper_lines = (line.upper() for line in with_iter(open('foo')))

    Any context manager which returns an iterable is a candidate for
    ``with_iter``.

    """
    with context_manager as iterable:
        yield from iterable


def one(iterable, too_short=None, too_long=None):
    """Return the first item from *iterable*, which is expected to contain only
    that item. Raise an exception if *iterable* is empty or has more than one
    item.

    :func:`one` is useful for ensuring that an iterable contains only one item.
    For example, it can be used to retrieve the result of a database query
    that is expected to return a single row.

    If *iterable* is empty, ``ValueError`` will be raised. You may specify a
    different exception with the *too_short* keyword:

        >>> it = []
        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        ValueError: too many items in iterable (expected 1)'
        >>> too_short = IndexError('too few items')
        >>> one(it, too_short=too_short)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        IndexError: too few items

    Similarly, if *iterable* contains more than one item, ``ValueError`` will
    be raised. You may specify a different exception with the *too_long*
    keyword:

        >>> it = ['too', 'many']
        >>> one(it)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        ValueError: Expected exactly one item in iterable, but got 'too',
        'many', and perhaps more.
        >>> too_long = RuntimeError
        >>> one(it, too_long=too_long)  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        RuntimeError

    Note that :func:`one` attempts to advance *iterable* twice to ensure there
    is only one item. See :func:`spy` or :func:`peekable` to check iterable
    contents less destructively.

    """
    it = iter(iterable)

    try:
        first_value = next(it)
    except StopIteration as e:
        raise (
            too_short or ValueError('too few items in iterable (expected 1)')
        ) from e

    try:
        second_value = next(it)
    except StopIteration:
        pass
    else:
        msg = (
            'Expected exactly one item in iterable, but got {!r}, {!r}, '
            'and perhaps more.'.format(first_value, second_value)
        )
        raise too_long or ValueError(msg)

    return first_value


def distinct_permutations(iterable, r=None):
    """Yield successive distinct permutations of the elements in *iterable*.

        >>> sorted(distinct_permutations([1, 0, 1]))
        [(0, 1, 1), (1, 0, 1), (1, 1, 0)]

    Equivalent to ``set(permutations(iterable))``, except duplicates are not
    generated and thrown away. For larger input sequences this is much more
    efficient.

    Duplicate permutations arise when there are duplicated elements in the
    input iterable. The number of items returned is
    `n! / (x_1! * x_2! * ... * x_n!)`, where `n` is the total number of
    items input, and each `x_i` is the count of a distinct item in the input
    sequence.

    If *r* is given, only the *r*-length permutations are yielded.

        >>> sorted(distinct_permutations([1, 0, 1], r=2))
        [(0, 1), (1, 0), (1, 1)]
        >>> sorted(distinct_permutations(range(3), r=2))
        [(0, 1), (0, 2), (1, 0), (1, 2), (2, 0), (2, 1)]

    """
    # Algorithm: https://w.wiki/Qai
    def _full(A):
        while True:
            # Yield the permutation we have
            yield tuple(A)

            # Find the largest index i such that A[i] < A[i + 1]
            for i in range(size - 2, -1, -1):
                if A[i] < A[i + 1]:
                    break
            #  If no such index exists, this permutation is the last one
            else:
                return

            # Find the largest index j greater than j such that A[i] < A[j]
            for j in range(size - 1, i, -1):
                if A[i] < A[j]:
                    break

            # Swap the value of A[i] with that of A[j], then reverse the
            # sequence from A[i + 1] to form the new permutation
            A[i], A[j] = A[j], A[i]
            A[i + 1 :] = A[: i - size : -1]  # A[i + 1:][::-1]

    # Algorithm: modified from the above
    def _partial(A, r):
        # Split A into the first r items and the last r items
        head, tail = A[:r], A[r:]
        right_head_indexes = range(r - 1, -1, -1)
        left_tail_indexes = range(len(tail))

        while True:
            # Yield the permutation we have
            yield tuple(head)

            # Starting from the right, find the first index of the head with
            # value smaller than the maximum value of the tail - call it i.
            pivot = tail[-1]
            for i in right_head_indexes:
                if head[i] < pivot:
                    break
                pivot = head[i]
            else:
                return

            # Starting from the left, find the first value of the tail
            # with a value greater than head[i] and swap.
            for j in left_tail_indexes:
                if tail[j] > head[i]:
                    head[i], tail[j] = tail[j], head[i]
                    break
            # If we didn't find one, start from the right and find the first
            # index of the head with a value greater than head[i] and swap.
            else:
                for j in right_head_indexes:
                    if head[j] > head[i]:
                        head[i], head[j] = head[j], head[i]
                        break

            # Reverse head[i + 1:] and swap it with tail[:r - (i + 1)]
            tail += head[: i - r : -1]  # head[i + 1:][::-1]
            i += 1
            head[i:], tail[:] = tail[: r - i], tail[r - i :]

    items = sorted(iterable)

    size = len(items)
    if r is None:
        r = size

    if 0 < r <= size:
        return _full(items) if (r == size) else _partial(items, r)

    return iter(() if r else ((),))


def intersperse(e, iterable, n=1):
    """Intersperse filler element *e* among the items in *iterable*, leaving
    *n* items between each filler element.

        >>> list(intersperse('!', [1, 2, 3, 4, 5]))
        [1, '!', 2, '!', 3, '!', 4, '!', 5]

        >>> list(intersperse(None, [1, 2, 3, 4, 5], n=2))
        [1, 2, None, 3, 4, None, 5]

    """
    if n == 0:
        raise ValueError('n must be > 0')
    elif n == 1:
        # interleave(repeat(e), iterable) -> e, x_0, e, e, x_1, e, x_2...
        # islice(..., 1, None) -> x_0, e, e, x_1, e, x_2...
        return islice(interleave(repeat(e), iterable), 1, None)
    else:
        # interleave(filler, chunks) -> [e], [x_0, x_1], [e], [x_2, x_3]...
        # islice(..., 1, None) -> [x_0, x_1], [e], [x_2, x_3]...
        # flatten(...) -> x_0, x_1, e, x_2, x_3...
        filler = repeat([e])
        chunks = chunked(iterable, n)
        return flatten(islice(interleave(filler, chunks), 1, None))


def unique_to_each(*iterables):
    """Return the elements from each of the input iterables that aren't in the
    other input iterables.

    For example, suppose you have a set of packages, each with a set of
    dependencies::

        {'pkg_1': {'A', 'B'}, 'pkg_2': {'B', 'C'}, 'pkg_3': {'B', 'D'}}

    If you remove one package, which dependencies can also be removed?

    If ``pkg_1`` is removed, then ``A`` is no longer necessary - it is not
    associated with ``pkg_2`` or ``pkg_3``. Similarly, ``C`` is only needed for
    ``pkg_2``, and ``D`` is only needed for ``pkg_3``::

        >>> unique_to_each({'A', 'B'}, {'B', 'C'}, {'B', 'D'})
        [['A'], ['C'], ['D']]

    If there are duplicates in one input iterable that aren't in the others
    they will be duplicated in the output. Input order is preserved::

        >>> unique_to_each("mississippi", "missouri")
        [['p', 'p'], ['o', 'u', 'r']]

    It is assumed that the elements of each iterable are hashable.

    """
    pool = [list(it) for it in iterables]
    counts = Counter(chain.from_iterable(map(set, pool)))
    uniques = {element for element in counts if counts[element] == 1}
    return [list(filter(uniques.__contains__, it)) for it in pool]


def windowed(seq, n, fillvalue=None, step=1):
    """Return a sliding window of width *n* over the given iterable.

        >>> all_windows = windowed([1, 2, 3, 4, 5], 3)
        >>> list(all_windows)
        [(1, 2, 3), (2, 3, 4), (3, 4, 5)]

    When the window is larger than the iterable, *fillvalue* is used in place
    of missing values:

        >>> list(windowed([1, 2, 3], 4))
        [(1, 2, 3, None)]

    Each window will advance in increments of *step*:

        >>> list(windowed([1, 2, 3, 4, 5, 6], 3, fillvalue='!', step=2))
        [(1, 2, 3), (3, 4, 5), (5, 6, '!')]

    To slide into the iterable's items, use :func:`chain` to add filler items
    to the left:

        >>> iterable = [1, 2, 3, 4]
        >>> n = 3
        >>> padding = [None] * (n - 1)
        >>> list(windowed(chain(padding, iterable), 3))
        [(None, None, 1), (None, 1, 2), (1, 2, 3), (2, 3, 4)]
    """
    if n < 0:
        raise ValueError('n must be >= 0')
    if n == 0:
        yield tuple()
        return
    if step < 1:
        raise ValueError('step must be >= 1')

    window = deque(maxlen=n)
    i = n
    for _ in map(window.append, seq):
        i -= 1
        if not i:
            i = step
            yield tuple(window)

    size = len(window)
    if size < n:
        yield tuple(chain(window, repeat(fillvalue, n - size)))
    elif 0 < i < min(step, n):
        window += (fillvalue,) * i
        yield tuple(window)


def substrings(iterable):
    """Yield all of the substrings of *iterable*.

        >>> [''.join(s) for s in substrings('more')]
        ['m', 'o', 'r', 'e', 'mo', 'or', 're', 'mor', 'ore', 'more']

    Note that non-string iterables can also be subdivided.

        >>> list(substrings([0, 1, 2]))
        [(0,), (1,), (2,), (0, 1), (1, 2), (0, 1, 2)]

    """
    # The length-1 substrings
    seq = []
    for item in iter(iterable):
        seq.append(item)
        yield (item,)
    seq = tuple(seq)
    item_count = len(seq)

    # And the rest
    for n in range(2, item_count + 1):
        for i in range(item_count - n + 1):
            yield seq[i : i + n]


def substrings_indexes(seq, reverse=False):
    """Yield all substrings and their positions in *seq*

    The items yielded will be a tuple of the form ``(substr, i, j)``, where
    ``substr == seq[i:j]``.

    This function only works for iterables that support slicing, such as
    ``str`` objects.

    >>> for item in substrings_indexes('more'):
    ...    print(item)
    ('m', 0, 1)
    ('o', 1, 2)
    ('r', 2, 3)
    ('e', 3, 4)
    ('mo', 0, 2)
    ('or', 1, 3)
    ('re', 2, 4)
    ('mor', 0, 3)
    ('ore', 1, 4)
    ('more', 0, 4)

    Set *reverse* to ``True`` to yield the same items in the opposite order.


    """
    r = range(1, len(seq) + 1)
    if reverse:
        r = reversed(r)
    return (
        (seq[i : i + L], i, i + L) for L in r for i in range(len(seq) - L + 1)
    )


class bucket:
    """Wrap *iterable* and return an object that buckets it iterable into
    child iterables based on a *key* function.

        >>> iterable = ['a1', 'b1', 'c1', 'a2', 'b2', 'c2', 'b3']
        >>> s = bucket(iterable, key=lambda x: x[0])  # Bucket by 1st character
        >>> sorted(list(s))  # Get the keys
        ['a', 'b', 'c']
        >>> a_iterable = s['a']
        >>> next(a_iterable)
        'a1'
        >>> next(a_iterable)
        'a2'
        >>> list(s['b'])
        ['b1', 'b2', 'b3']

    The original iterable will be advanced and its items will be cached until
    they are used by the child iterables. This may require significant storage.

    By default, attempting to select a bucket to which no items belong  will
    exhaust the iterable and cache all values.
    If you specify a *validator* function, selected buckets will instead be
    checked against it.

        >>> from itertools import count
        >>> it = count(1, 2)  # Infinite sequence of odd numbers
        >>> key = lambda x: x % 10  # Bucket by last digit
        >>> validator = lambda x: x in {1, 3, 5, 7, 9}  # Odd digits only
        >>> s = bucket(it, key=key, validator=validator)
        >>> 2 in s
        False
        >>> list(s[2])
        []

    """

    def __init__(self, iterable, key, validator=None):
        self._it = iter(iterable)
        self._key = key
        self._cache = defaultdict(deque)
        self._validator = validator or (lambda x: True)

    def __contains__(self, value):
        if not self._validator(value):
            return False

        try:
            item = next(self[value])
        except StopIteration:
            return False
        else:
            self._cache[value].appendleft(item)

        return True

    def _get_values(self, value):
        """
        Helper to yield items from the parent iterator that match *value*.
        Items that don't match are stored in the local cache as they
        are encountered.
        """
        while True:
            # If we've cached some items that match the target value, emit
            # the first one and evict it from the cache.
            if self._cache[value]:
                yield self._cache[value].popleft()
            # Otherwise we need to advance the parent iterator to search for
            # a matching item, caching the rest.
            else:
                while True:
                    try:
                        item = next(self._it)
                    except StopIteration:
                        return
                    item_value = self._key(item)
                    if item_value == value:
                        yield item
                        break
                    elif self._validator(item_value):
                        self._cache[item_value].append(item)

    def __iter__(self):
        for item in self._it:
            item_value = self._key(item)
            if self._validator(item_value):
                self._cache[item_value].append(item)

        yield from self._cache.keys()

    def __getitem__(self, value):
        if not self._validator(value):
            return iter(())

        return self._get_values(value)


def spy(iterable, n=1):
    """Return a 2-tuple with a list containing the first *n* elements of
    *iterable*, and an iterator with the same items as *iterable*.
    This allows you to "look ahead" at the items in the iterable without
    advancing it.

    There is one item in the list by default:

        >>> iterable = 'abcdefg'
        >>> head, iterable = spy(iterable)
        >>> head
        ['a']
        >>> list(iterable)
        ['a', 'b', 'c', 'd', 'e', 'f', 'g']

    You may use unpacking to retrieve items instead of lists:

        >>> (head,), iterable = spy('abcdefg')
        >>> head
        'a'
        >>> (first, second), iterable = spy('abcdefg', 2)
        >>> first
        'a'
        >>> second
        'b'

    The number of items requested can be larger than the number of items in
    the iterable:

        >>> iterable = [1, 2, 3, 4, 5]
        >>> head, iterable = spy(iterable, 10)
        >>> head
        [1, 2, 3, 4, 5]
        >>> list(iterable)
        [1, 2, 3, 4, 5]

    """
    it = iter(iterable)
    head = take(n, it)

    return head.copy(), chain(head, it)


def interleave(*iterables):
    """Return a new iterable yielding from each iterable in turn,
    until the shortest is exhausted.

        >>> list(interleave([1, 2, 3], [4, 5], [6, 7, 8]))
        [1, 4, 6, 2, 5, 7]

    For a version that doesn't terminate after the shortest iterable is
    exhausted, see :func:`interleave_longest`.

    """
    return chain.from_iterable(zip(*iterables))


def interleave_longest(*iterables):
    """Return a new iterable yielding from each iterable in turn,
    skipping any that are exhausted.

        >>> list(interleave_longest([1, 2, 3], [4, 5], [6, 7, 8]))
        [1, 4, 6, 2, 5, 7, 3, 8]

    This function produces the same output as :func:`roundrobin`, but may
    perform better for some inputs (in particular when the number of iterables
    is large).

    """
    i = chain.from_iterable(zip_longest(*iterables, fillvalue=_marker))
    return (x for x in i if x is not _marker)


def collapse(iterable, base_type=None, levels=None):
    """Flatten an iterable with multiple levels of nesting (e.g., a list of
    lists of tuples) into non-iterable types.

        >>> iterable = [(1, 2), ([3, 4], [[5], [6]])]
        >>> list(collapse(iterable))
        [1, 2, 3, 4, 5, 6]

    Binary and text strings are not considered iterable and
    will not be collapsed.

    To avoid collapsing other types, specify *base_type*:

        >>> iterable = ['ab', ('cd', 'ef'), ['gh', 'ij']]
        >>> list(collapse(iterable, base_type=tuple))
        ['ab', ('cd', 'ef'), 'gh', 'ij']

    Specify *levels* to stop flattening after a certain level:

    >>> iterable = [('a', ['b']), ('c', ['d'])]
    >>> list(collapse(iterable))  # Fully flattened
    ['a', 'b', 'c', 'd']
    >>> list(collapse(iterable, levels=1))  # Only one level flattened
    ['a', ['b'], 'c', ['d']]

    """

    def walk(node, level):
        if (
            ((levels is not None) and (level > levels))
            or isinstance(node, (str, bytes))
            or ((base_type is not None) and isinstance(node, base_type))
        ):
            yield node
            return

        try:
            tree = iter(node)
        except TypeError:
            yield node
            return
        else:
            for child in tree:
                yield from walk(child, level + 1)

    yield from walk(iterable, 0)


def side_effect(func, iterable, chunk_size=None, before=None, after=None):
    """Invoke *func* on each item in *iterable* (or on each *chunk_size* group
    of items) before yielding the item.

    `func` must be a function that takes a single argument. Its return value
    will be discarded.

    *before* and *after* are optional functions that take no arguments. They
    will be executed before iteration starts and after it ends, respectively.

    `side_effect` can be used for logging, updating progress bars, or anything
    that is not functionally "pure."

    Emitting a status message:

        >>> from more_itertools import consume
        >>> func = lambda item: print('Received {}'.format(item))
        >>> consume(side_effect(func, range(2)))
        Received 0
        Received 1

    Operating on chunks of items:

        >>> pair_sums = []
        >>> func = lambda chunk: pair_sums.append(sum(chunk))
        >>> list(side_effect(func, [0, 1, 2, 3, 4, 5], 2))
        [0, 1, 2, 3, 4, 5]
        >>> list(pair_sums)
        [1, 5, 9]

    Writing to a file-like object:

        >>> from io import StringIO
        >>> from more_itertools import consume
        >>> f = StringIO()
        >>> func = lambda x: print(x, file=f)
        >>> before = lambda: print(u'HEADER', file=f)
        >>> after = f.close
        >>> it = [u'a', u'b', u'c']
        >>> consume(side_effect(func, it, before=before, after=after))
        >>> f.closed
        True

    """
    try:
        if before is not None:
            before()

        if chunk_size is None:
            for item in iterable:
                func(item)
                yield item
        else:
            for chunk in chunked(iterable, chunk_size):
                func(chunk)
                yield from chunk
    finally:
        if after is not None:
            after()


def sliced(seq, n, strict=False):
    """Yield slices of length *n* from the sequence *seq*.

    >>> list(sliced((1, 2, 3, 4, 5, 6), 3))
    [(1, 2, 3), (4, 5, 6)]

    By the default, the last yielded slice will have fewer than *n* elements
    if the length of *seq* is not divisible by *n*:

    >>> list(sliced((1, 2, 3, 4, 5, 6, 7, 8), 3))
    [(1, 2, 3), (4, 5, 6), (7, 8)]

    If the length of *seq* is not divisible by *n* and *strict* is
    ``True``, then ``ValueError`` will be raised before the last
    slice is yielded.

    This function will only work for iterables that support slicing.
    For non-sliceable iterables, see :func:`chunked`.

    """
    iterator = takewhile(len, (seq[i : i + n] for i in count(0, n)))
    if strict:

        def ret():
            for _slice in iterator:
                if len(_slice) != n:
                    raise ValueError("seq is not divisible by n.")
                yield _slice

        return iter(ret())
    else:
        return iterator


def split_at(iterable, pred, maxsplit=-1, keep_separator=False):
    """Yield lists of items from *iterable*, where each list is delimited by
    an item where callable *pred* returns ``True``.

        >>> list(split_at('abcdcba', lambda x: x == 'b'))
        [['a'], ['c', 'd', 'c'], ['a']]

        >>> list(split_at(range(10), lambda n: n % 2 == 1))
        [[0], [2], [4], [6], [8], []]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_at(range(10), lambda n: n % 2 == 1, maxsplit=2))
        [[0], [2], [4, 5, 6, 7, 8, 9]]

    By default, the delimiting items are not included in the output.
    The include them, set *keep_separator* to ``True``.

        >>> list(split_at('abcdcba', lambda x: x == 'b', keep_separator=True))
        [['a'], ['b'], ['c', 'd', 'c'], ['b'], ['a']]

    """
    if maxsplit == 0:
        yield list(iterable)
        return

    buf = []
    it = iter(iterable)
    for item in it:
        if pred(item):
            yield buf
            if keep_separator:
                yield [item]
            if maxsplit == 1:
                yield list(it)
                return
            buf = []
            maxsplit -= 1
        else:
            buf.append(item)
    yield buf


def split_before(iterable, pred, maxsplit=-1):
    """Yield lists of items from *iterable*, where each list ends just before
    an item for which callable *pred* returns ``True``:

        >>> list(split_before('OneTwo', lambda s: s.isupper()))
        [['O', 'n', 'e'], ['T', 'w', 'o']]

        >>> list(split_before(range(10), lambda n: n % 3 == 0))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9]]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_before(range(10), lambda n: n % 3 == 0, maxsplit=2))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8, 9]]
    """
    if maxsplit == 0:
        yield list(iterable)
        return

    buf = []
    it = iter(iterable)
    for item in it:
        if pred(item) and buf:
            yield buf
            if maxsplit == 1:
                yield [item] + list(it)
                return
            buf = []
            maxsplit -= 1
        buf.append(item)
    if buf:
        yield buf


def split_after(iterable, pred, maxsplit=-1):
    """Yield lists of items from *iterable*, where each list ends with an
    item where callable *pred* returns ``True``:

        >>> list(split_after('one1two2', lambda s: s.isdigit()))
        [['o', 'n', 'e', '1'], ['t', 'w', 'o', '2']]

        >>> list(split_after(range(10), lambda n: n % 3 == 0))
        [[0], [1, 2, 3], [4, 5, 6], [7, 8, 9]]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_after(range(10), lambda n: n % 3 == 0, maxsplit=2))
        [[0], [1, 2, 3], [4, 5, 6, 7, 8, 9]]

    """
    if maxsplit == 0:
        yield list(iterable)
        return

    buf = []
    it = iter(iterable)
    for item in it:
        buf.append(item)
        if pred(item) and buf:
            yield buf
            if maxsplit == 1:
                yield list(it)
                return
            buf = []
            maxsplit -= 1
    if buf:
        yield buf


def split_when(iterable, pred, maxsplit=-1):
    """Split *iterable* into pieces based on the output of *pred*.
    *pred* should be a function that takes successive pairs of items and
    returns ``True`` if the iterable should be split in between them.

    For example, to find runs of increasing numbers, split the iterable when
    element ``i`` is larger than element ``i + 1``:

        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2], lambda x, y: x > y))
        [[1, 2, 3, 3], [2, 5], [2, 4], [2]]

    At most *maxsplit* splits are done. If *maxsplit* is not specified or -1,
    then there is no limit on the number of splits:

        >>> list(split_when([1, 2, 3, 3, 2, 5, 2, 4, 2],
        ...                 lambda x, y: x > y, maxsplit=2))
        [[1, 2, 3, 3], [2, 5], [2, 4, 2]]

    """
    if maxsplit == 0:
        yield list(iterable)
        return

    it = iter(iterable)
    try:
        cur_item = next(it)
    except StopIteration:
        return

    buf = [cur_item]
    for next_item in it:
        if pred(cur_item, next_item):
            yield buf
            if maxsplit == 1:
                yield [next_item] + list(it)
                return
            buf = []
            maxsplit -= 1

        buf.append(next_item)
        cur_item = next_item

    yield buf


def split_into(iterable, sizes):
    """Yield a list of sequential items from *iterable* of length 'n' for each
    integer 'n' in *sizes*.

        >>> list(split_into([1,2,3,4,5,6], [1,2,3]))
        [[1], [2, 3], [4, 5, 6]]

    If the sum of *sizes* is smaller than the length of *iterable*, then the
    remaining items of *iterable* will not be returned.

        >>> list(split_into([1,2,3,4,5,6], [2,3]))
        [[1, 2], [3, 4, 5]]

    If the sum of *sizes* is larger than the length of *iterable*, fewer items
    will be returned in the iteration that overruns *iterable* and further
    lists will be empty:

        >>> list(split_into([1,2,3,4], [1,2,3,4]))
        [[1], [2, 3], [4], []]

    When a ``None`` object is encountered in *sizes*, the returned list will
    contain items up to the end of *iterable* the same way that itertools.slice
    does:

        >>> list(split_into([1,2,3,4,5,6,7,8,9,0], [2,3,None]))
        [[1, 2], [3, 4, 5], [6, 7, 8, 9, 0]]

    :func:`split_into` can be useful for grouping a series of items where the
    sizes of the groups are not uniform. An example would be where in a row
    from a table, multiple columns represent elements of the same feature
    (e.g. a point represented by x,y,z) but, the format is not the same for
    all columns.
    """
    # convert the iterable argument into an iterator so its contents can
    # be consumed by islice in case it is a generator
    it = iter(iterable)

    for size in sizes:
        if size is None:
            yield list(it)
            return
        else:
            yield list(islice(it, size))


def padded(iterable, fillvalue=None, n=None, next_multiple=False):
    """Yield the elements from *iterable*, followed by *fillvalue*, such that
    at least *n* items are emitted.

        >>> list(padded([1, 2, 3], '?', 5))
        [1, 2, 3, '?', '?']

    If *next_multiple* is ``True``, *fillvalue* will be emitted until the
    number of items emitted is a multiple of *n*::

        >>> list(padded([1, 2, 3, 4], n=3, next_multiple=True))
        [1, 2, 3, 4, None, None]

    If *n* is ``None``, *fillvalue* will be emitted indefinitely.

    """
    it = iter(iterable)
    if n is None:
        yield from chain(it, repeat(fillvalue))
    elif n < 1:
        raise ValueError('n must be at least 1')
    else:
        item_count = 0
        for item in it:
            yield item
            item_count += 1

        remaining = (n - item_count) % n if next_multiple else n - item_count
        for _ in range(remaining):
            yield fillvalue


def repeat_last(iterable, default=None):
    """After the *iterable* is exhausted, keep yielding its last element.

        >>> list(islice(repeat_last(range(3)), 5))
        [0, 1, 2, 2, 2]

    If the iterable is empty, yield *default* forever::

        >>> list(islice(repeat_last(range(0), 42), 5))
        [42, 42, 42, 42, 42]

    """
    item = _marker
    for item in iterable:
        yield item
    final = default if item is _marker else item
    yield from repeat(final)


def distribute(n, iterable):
    """Distribute the items from *iterable* among *n* smaller iterables.

        >>> group_1, group_2 = distribute(2, [1, 2, 3, 4, 5, 6])
        >>> list(group_1)
        [1, 3, 5]
        >>> list(group_2)
        [2, 4, 6]

    If the length of *iterable* is not evenly divisible by *n*, then the
    length of the returned iterables will not be identical:

        >>> children = distribute(3, [1, 2, 3, 4, 5, 6, 7])
        >>> [list(c) for c in children]
        [[1, 4, 7], [2, 5], [3, 6]]

    If the length of *iterable* is smaller than *n*, then the last returned
    iterables will be empty:

        >>> children = distribute(5, [1, 2, 3])
        >>> [list(c) for c in children]
        [[1], [2], [3], [], []]

    This function uses :func:`itertools.tee` and may require significant
    storage. If you need the order items in the smaller iterables to match the
    original iterable, see :func:`divide`.

    """
    if n < 1:
        raise ValueError('n must be at least 1')

    children = tee(iterable, n)
    return [islice(it, index, None, n) for index, it in enumerate(children)]


def stagger(iterable, offsets=(-1, 0, 1), longest=False, fillvalue=None):
    """Yield tuples whose elements are offset from *iterable*.
    The amount by which the `i`-th item in each tuple is offset is given by
    the `i`-th item in *offsets*.

        >>> list(stagger([0, 1, 2, 3]))
        [(None, 0, 1), (0, 1, 2), (1, 2, 3)]
        >>> list(stagger(range(8), offsets=(0, 2, 4)))
        [(0, 2, 4), (1, 3, 5), (2, 4, 6), (3, 5, 7)]

    By default, the sequence will end when the final element of a tuple is the
    last item in the iterable. To continue until the first element of a tuple
    is the last item in the iterable, set *longest* to ``True``::

        >>> list(stagger([0, 1, 2, 3], longest=True))
        [(None, 0, 1), (0, 1, 2), (1, 2, 3), (2, 3, None), (3, None, None)]

    By default, ``None`` will be used to replace offsets beyond the end of the
    sequence. Specify *fillvalue* to use some other value.

    """
    children = tee(iterable, len(offsets))

    return zip_offset(
        *children, offsets=offsets, longest=longest, fillvalue=fillvalue
    )


class UnequalIterablesError(ValueError):
    def __init__(self, details=None):
        msg = 'Iterables have different lengths'
        if details is not None:
            msg += (': index 0 has length {}; index {} has length {}').format(
                *details
            )

        super().__init__(msg)


def _zip_equal_generator(iterables):
    for combo in zip_longest(*iterables, fillvalue=_marker):
        for val in combo:
            if val is _marker:
                raise UnequalIterablesError()
        yield combo


def zip_equal(*iterables):
    """``zip`` the input *iterables* together, but raise
    ``UnequalIterablesError`` if they aren't all the same length.

        >>> it_1 = range(3)
        >>> it_2 = iter('abc')
        >>> list(zip_equal(it_1, it_2))
        [(0, 'a'), (1, 'b'), (2, 'c')]

        >>> it_1 = range(3)
        >>> it_2 = iter('abcd')
        >>> list(zip_equal(it_1, it_2)) # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        ...
        more_itertools.more.UnequalIterablesError: Iterables have different
        lengths

    """
    if hexversion >= 0x30A00A6:
        warnings.warn(
            (
                'zip_equal will be removed in a future version of '
                'more-itertools. Use the builtin zip function with '
                'strict=True instead.'
            ),
            DeprecationWarning,
        )
    # Check whether the iterables are all the same size.
    try:
        first_size = len(iterables[0])
        for i, it in enumerate(iterables[1:], 1):
            size = len(it)
            if size != first_size:
                break
        else:
            # If we didn't break out, we can use the built-in zip.
            return zip(*iterables)

        # If we did break out, there was a mismatch.
        raise UnequalIterablesError(details=(first_size, i, size))
    # If any one of the iterables didn't have a length, start reading
    # them until one runs out.
    except TypeError:
        return _zip_equal_generator(iterables)


def zip_offset(*iterables, offsets, longest=False, fillvalue=None):
    """``zip`` the input *iterables* together, but offset the `i`-th iterable
    by the `i`-th item in *offsets*.

        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1)))
        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e')]

    This can be used as a lightweight alternative to SciPy or pandas to analyze
    data sets in which some series have a lead or lag relationship.

    By default, the sequence will end when the shortest iterable is exhausted.
    To continue until the longest iterable is exhausted, set *longest* to
    ``True``.

        >>> list(zip_offset('0123', 'abcdef', offsets=(0, 1), longest=True))
        [('0', 'b'), ('1', 'c'), ('2', 'd'), ('3', 'e'), (None, 'f')]

    By default, ``None`` will be used to replace offsets beyond the end of the
    sequence. Specify *fillvalue* to use some other value.

    """
    if len(iterables) != len(offsets):
        raise ValueError("Number of iterables and offsets didn't match")

    staggered = []
    for it, n in zip(iterables, offsets):
        if n < 0:
            staggered.append(chain(repeat(fillvalue, -n), it))
        elif n > 0:
            staggered.append(islice(it, n, None))
        else:
            staggered.append(it)

    if longest:
        return zip_longest(*staggered, fillvalue=fillvalue)

    return zip(*staggered)


def sort_together(iterables, key_list=(0,), key=None, reverse=False):
    """Return the input iterables sorted together, with *key_list* as the
    priority for sorting. All iterables are trimmed to the length of the
    shortest one.

    This can be used like the sorting function in a spreadsheet. If each
    iterable represents a column of data, the key list determines which
    columns are used for sorting.

    By default, all iterables are sorted using the ``0``-th iterable::

        >>> iterables = [(4, 3, 2, 1), ('a', 'b', 'c', 'd')]
        >>> sort_together(iterables)
        [(1, 2, 3, 4), ('d', 'c', 'b', 'a')]

    Set a different key list to sort according to another iterable.
    Specifying multiple keys dictates how ties are broken::

        >>> iterables = [(3, 1, 2), (0, 1, 0), ('c', 'b', 'a')]
        >>> sort_together(iterables, key_list=(1, 2))
        [(2, 3, 1), (0, 0, 1), ('a', 'c', 'b')]

    To sort by a function of the elements of the iterable, pass a *key*
    function. Its arguments are the elements of the iterables corresponding to
    the key list::

        >>> names = ('a', 'b', 'c')
        >>> lengths = (1, 2, 3)
        >>> widths = (5, 2, 1)
        >>> def area(length, width):
        ...     return length * width
        >>> sort_together([names, lengths, widths], key_list=(1, 2), key=area)
        [('c', 'b', 'a'), (3, 2, 1), (1, 2, 5)]

    Set *reverse* to ``True`` to sort in descending order.

        >>> sort_together([(1, 2, 3), ('c', 'b', 'a')], reverse=True)
        [(3, 2, 1), ('a', 'b', 'c')]

    """
    if key is None:
        # if there is no key function, the key argument to sorted is an
        # itemgetter
        key_argument = itemgetter(*key_list)
    else:
        # if there is a key function, call it with the items at the offsets
        # specified by the key function as arguments
        key_list = list(key_list)
        if len(key_list) == 1:
            # if key_list contains a single item, pass the item at that offset
            # as the only argument to the key function
            key_offset = key_list[0]
            key_argument = lambda zipped_items: key(zipped_items[key_offset])
        else:
            # if key_list contains multiple items, use itemgetter to return a
            # tuple of items, which we pass as *args to the key function
            get_key_items = itemgetter(*key_list)
            key_argument = lambda zipped_items: key(
                *get_key_items(zipped_items)
            )

    return list(
        zip(*sorted(zip(*iterables), key=key_argument, reverse=reverse))
    )


def unzip(iterable):
    """The inverse of :func:`zip`, this function disaggregates the elements
    of the zipped *iterable*.

    The ``i``-th iterable contains the ``i``-th element from each element
    of the zipped iterable. The first element is used to to determine the
    length of the remaining elements.

        >>> iterable = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
        >>> letters, numbers = unzip(iterable)
        >>> list(letters)
        ['a', 'b', 'c', 'd']
        >>> list(numbers)
        [1, 2, 3, 4]

    This is similar to using ``zip(*iterable)``, but it avoids reading
    *iterable* into memory. Note, however, that this function uses
    :func:`itertools.tee` and thus may require significant storage.

    """
    head, iterable = spy(iter(iterable))
    if not head:
        # empty iterable, e.g. zip([], [], [])
        return ()
    # spy returns a one-length iterable as head
    head = head[0]
    iterables = tee(iterable, len(head))

    def itemgetter(i):
        def getter(obj):
            try:
                return obj[i]
            except IndexError:
                # basically if we have an iterable like
                # iter([(1, 2, 3), (4, 5), (6,)])
                # the second unzipped iterable would fail at the third tuple
                # since it would try to access tup[1]
                # same with the third unzipped iterable and the second tuple
                # to support these "improperly zipped" iterables,
                # we create a custom itemgetter
                # which just stops the unzipped iterables
                # at first length mismatch
                raise StopIteration

        return getter

    return tuple(map(itemgetter(i), it) for i, it in enumerate(iterables))


def divide(n, iterable):
    """Divide the elements from *iterable* into *n* parts, maintaining
    order.

        >>> group_1, group_2 = divide(2, [1, 2, 3, 4, 5, 6])
        >>> list(group_1)
        [1, 2, 3]
        >>> list(group_2)
        [4, 5, 6]

    If the length of *iterable* is not evenly divisible by *n*, then the
    length of the returned iterables will not be identical:

        >>> children = divide(3, [1, 2, 3, 4, 5, 6, 7])
        >>> [list(c) for c in children]
        [[1, 2, 3], [4, 5], [6, 7]]

    If the length of the iterable is smaller than n, then the last returned
    iterables will be empty:

        >>> children = divide(5, [1, 2, 3])
        >>> [list(c) for c in children]
        [[1], [2], [3], [], []]

    This function will exhaust the iterable before returning and may require
    significant storage. If order is not important, see :func:`distribute`,
    which does not first pull the iterable into memory.

    """
    if n < 1:
        raise ValueError('n must be at least 1')

    try:
        iterable[:0]
    except TypeError:
        seq = tuple(iterable)
    else:
        seq = iterable

    q, r = divmod(len(seq), n)

    ret = []
    stop = 0
    for i in range(1, n + 1):
        start = stop
        stop += q + 1 if i <= r else q
        ret.append(iter(seq[start:stop]))

    return ret


def always_iterable(obj, base_type=(str, bytes)):
    """If *obj* is iterable, return an iterator over its items::

        >>> obj = (1, 2, 3)
        >>> list(always_iterable(obj))
        [1, 2, 3]

    If *obj* is not iterable, return a one-item iterable containing *obj*::

        >>> obj = 1
        >>> list(always_iterable(obj))
        [1]

    If *obj* is ``None``, return an empty iterable:

        >>> obj = None
        >>> list(always_iterable(None))
        []

    By default, binary and text strings are not considered iterable::

        >>> obj = 'foo'
        >>> list(always_iterable(obj))
        ['foo']

    If *base_type* is set, objects for which ``isinstance(obj, base_type)``
    returns ``True`` won't be considered iterable.

        >>> obj = {'a': 1}
        >>> list(always_iterable(obj))  # Iterate over the dict's keys
        ['a']
        >>> list(always_iterable(obj, base_type=dict))  # Treat dicts as a unit
        [{'a': 1}]

    Set *base_type* to ``None`` to avoid any special handling and treat objects
    Python considers iterable as iterable:

        >>> obj = 'foo'
        >>> list(always_iterable(obj, base_type=None))
        ['f', 'o', 'o']
    """
    if obj is None:
        return iter(())

    if (base_type is not None) and isinstance(obj, base_type):
        return iter((obj,))

    try:
        return iter(obj)
    except TypeError:
        return iter((obj,))


def adjacent(predicate, iterable, distance=1):
    """Return an iterable over `(bool, item)` tuples where the `item` is
    drawn from *iterable* and the `bool` indicates whether
    that item satisfies the *predicate* or is adjacent to an item that does.

    For example, to find whether items are adjacent to a ``3``::

        >>> list(adjacent(lambda x: x == 3, range(6)))
        [(False, 0), (False, 1), (True, 2), (True, 3), (True, 4), (False, 5)]

    Set *distance* to change what counts as adjacent. For example, to find
    whether items are two places away from a ``3``:

        >>> list(adjacent(lambda x: x == 3, range(6), distance=2))
        [(False, 0), (True, 1), (True, 2), (True, 3), (True, 4), (True, 5)]

    This is useful for contextualizing the results of a search function.
    For example, a code comparison tool might want to identify lines that
    have changed, but also surrounding lines to give the viewer of the diff
    context.

    The predicate function will only be called once for each item in the
    iterable.

    See also :func:`groupby_transform`, which can be used with this function
    to group ranges of items with the same `bool` value.

    """
    # Allow distance=0 mainly for testing that it reproduces results with map()
    if distance < 0:
        raise ValueError('distance must be at least 0')

    i1, i2 = tee(iterable)
    padding = [False] * distance
    selected = chain(padding, map(predicate, i1), padding)
    adjacent_to_selected = map(any, windowed(selected, 2 * distance + 1))
    return zip(adjacent_to_selected, i2)


def groupby_transform(iterable, keyfunc=None, valuefunc=None, reducefunc=None):
    """An extension of :func:`itertools.groupby` that can apply transformations
    to the grouped data.

    * *keyfunc* is a function computing a key value for each item in *iterable*
    * *valuefunc* is a function that transforms the individual items from
      *iterable* after grouping
    * *reducefunc* is a function that transforms each group of items

    >>> iterable = 'aAAbBBcCC'
    >>> keyfunc = lambda k: k.upper()
    >>> valuefunc = lambda v: v.lower()
    >>> reducefunc = lambda g: ''.join(g)
    >>> list(groupby_transform(iterable, keyfunc, valuefunc, reducefunc))
    [('A', 'aaa'), ('B', 'bbb'), ('C', 'ccc')]

    Each optional argument defaults to an identity function if not specified.

    :func:`groupby_transform` is useful when grouping elements of an iterable
    using a separate iterable as the key. To do this, :func:`zip` the iterables
    and pass a *keyfunc* that extracts the first element and a *valuefunc*
    that extracts the second element::

        >>> from operator import itemgetter
        >>> keys = [0, 0, 1, 1, 1, 2, 2, 2, 3]
        >>> values = 'abcdefghi'
        >>> iterable = zip(keys, values)
        >>> grouper = groupby_transform(iterable, itemgetter(0), itemgetter(1))
        >>> [(k, ''.join(g)) for k, g in grouper]
        [(0, 'ab'), (1, 'cde'), (2, 'fgh'), (3, 'i')]

    Note that the order of items in the iterable is significant.
    Only adjacent items are grouped together, so if you don't want any
    duplicate groups, you should sort the iterable by the key function.

    """
    ret = groupby(iterable, keyfunc)
    if valuefunc:
        ret = ((k, map(valuefunc, g)) for k, g in ret)
    if reducefunc:
        ret = ((k, reducefunc(g)) for k, g in ret)

    return ret


class numeric_range(abc.Sequence, abc.Hashable):
    """An extension of the built-in ``range()`` function whose arguments can
    be any orderable numeric type.

    With only *stop* specified, *start* defaults to ``0`` and *step*
    defaults to ``1``. The output items will match the type of *stop*:

        >>> list(numeric_range(3.5))
        [0.0, 1.0, 2.0, 3.0]

    With only *start* and *stop* specified, *step* defaults to ``1``. The
    output items will match the type of *start*:

        >>> from decimal import Decimal
        >>> start = Decimal('2.1')
        >>> stop = Decimal('5.1')
        >>> list(numeric_range(start, stop))
        [Decimal('2.1'), Decimal('3.1'), Decimal('4.1')]

    With *start*, *stop*, and *step*  specified the output items will match
    the type of ``start + step``:

        >>> from fractions import Fraction
        >>> start = Fraction(1, 2)  # Start at 1/2
        >>> stop = Fraction(5, 2)  # End at 5/2
        >>> step = Fraction(1, 2)  # Count by 1/2
        >>> list(numeric_range(start, stop, step))
        [Fraction(1, 2), Fraction(1, 1), Fraction(3, 2), Fraction(2, 1)]

    If *step* is zero, ``ValueError`` is raised. Negative steps are supported:

        >>> list(numeric_range(3, -1, -1.0))
        [3.0, 2.0, 1.0, 0.0]

    Be aware of the limitations of floating point numbers; the representation
    of the yielded numbers may be surprising.

    ``datetime.datetime`` objects can be used for *start* and *stop*, if *step*
    is a ``datetime.timedelta`` object:

        >>> import datetime
        >>> start = datetime.datetime(2019, 1, 1)
        >>> stop = datetime.datetime(2019, 1, 3)
        >>> step = datetime.timedelta(days=1)
        >>> items = iter(numeric_range(start, stop, step))
        >>> next(items)
        datetime.datetime(2019, 1, 1, 0, 0)
        >>> next(items)
        datetime.datetime(2019, 1, 2, 0, 0)

    """

    _EMPTY_HASH = hash(range(0, 0))

    def __init__(self, *args):
        argc = len(args)
        if argc == 1:
            (self._stop,) = args
            self._start = type(self._stop)(0)
            self._step = type(self._stop - self._start)(1)
        elif argc == 2:
            self._start, self._stop = args
            self._step = type(self._stop - self._start)(1)
        elif argc == 3:
            self._start, self._stop, self._step = args
        elif argc == 0:
            raise TypeError(
                'numeric_range expected at least '
                '1 argument, got {}'.format(argc)
            )
        else:
            raise TypeError(
                'numeric_range expected at most '
                '3 arguments, got {}'.format(argc)
            )

        self._zero = type(self._step)(0)
        if self._step == self._zero:
            raise ValueError('numeric_range() arg 3 must not be zero')
        self._growing = self._step > self._zero
        self._init_len()

    def __bool__(self):
        if self._growing:
            return self._start < self._stop
        else:
            return self._start > self._stop

    def __contains__(self, elem):
        if self._growing:
            if self._start <= elem < self._stop:
                return (elem - self._start) % self._step == self._zero
        else:
            if self._start >= elem > self._stop:
                return (self._start - elem) % (-self._step) == self._zero

        return False

    def __eq__(self, other):
        if isinstance(other, numeric_range):
            empty_self = not bool(self)
            empty_other = not bool(other)
            if empty_self or empty_other:
                return empty_self and empty_other  # True if both empty
            else:
                return (
                    self._start == other._start
                    and self._step == other._step
                    and self._get_by_index(-1) == other._get_by_index(-1)
                )
        else:
            return False

    def __getitem__(self, key):
        if isinstance(key, int):
            return self._get_by_index(key)
        elif isinstance(key, slice):
            step = self._step if key.step is None else key.step * self._step

            if key.start is None or key.start <= -self._len:
                start = self._start
            elif key.start >= self._len:
                start = self._stop
            else:  # -self._len < key.start < self._len
                start = self._get_by_index(key.start)

            if key.stop is None or key.stop >= self._len:
                stop = self._stop
            elif key.stop <= -self._len:
                stop = self._start
            else:  # -self._len < key.stop < self._len
                stop = self._get_by_index(key.stop)

            return numeric_range(start, stop, step)
        else:
            raise TypeError(
                'numeric range indices must be '
                'integers or slices, not {}'.format(type(key).__name__)
            )

    def __hash__(self):
        if self:
            return hash((self._start, self._get_by_index(-1), self._step))
        else:
            return self._EMPTY_HASH

    def __iter__(self):
        values = (self._start + (n * self._step) for n in count())
        if self._growing:
            return takewhile(partial(gt, self._stop), values)
        else:
            return takewhile(partial(lt, self._stop), values)

    def __len__(self):
        return self._len

    def _init_len(self):
        if self._growing:
            start = self._start
            stop = self._stop
            step = self._step
        else:
            start = self._stop
            stop = self._start
            step = -self._step
        distance = stop - start
        if distance <= self._zero:
            self._len = 0
        else:  # distance > 0 and step > 0: regular euclidean division
            q, r = divmod(distance, step)
            self._len = int(q) + int(r != self._zero)

    def __reduce__(self):
        return numeric_range, (self._start, self._stop, self._step)

    def __repr__(self):
        if self._step == 1:
            return "numeric_range({}, {})".format(
                repr(self._start), repr(self._stop)
            )
        else:
            return "numeric_range({}, {}, {})".format(
                repr(self._start), repr(self._stop), repr(self._step)
            )

    def __reversed__(self):
        return iter(
            numeric_range(
                self._get_by_index(-1), self._start - self._step, -self._step
            )
        )

    def count(self, value):
        return int(value in self)

    def index(self, value):
        if self._growing:
            if self._start <= value < self._stop:
                q, r = divmod(value - self._start, self._step)
                if r == self._zero:
                    return int(q)
        else:
            if self._start >= value > self._stop:
                q, r = divmod(self._start - value, -self._step)
                if r == self._zero:
                    return int(q)

        raise ValueError("{} is not in numeric range".format(value))

    def _get_by_index(self, i):
        if i < 0:
            i += self._len
        if i < 0 or i >= self._len:
            raise IndexError("numeric range object index out of range")
        return self._start + i * self._step


def count_cycle(iterable, n=None):
    """Cycle through the items from *iterable* up to *n* times, yielding
    the number of completed cycles along with each item. If *n* is omitted the
    process repeats indefinitely.

    >>> list(count_cycle('AB', 3))
    [(0, 'A'), (0, 'B'), (1, 'A'), (1, 'B'), (2, 'A'), (2, 'B')]

    """
    iterable = tuple(iterable)
    if not iterable:
        return iter(())
    counter = count() if n is None else range(n)
    return ((i, item) for i in counter for item in iterable)


def mark_ends(iterable):
    """Yield 3-tuples of the form ``(is_first, is_last, item)``.

    >>> list(mark_ends('ABC'))
    [(True, False, 'A'), (False, False, 'B'), (False, True, 'C')]

    Use this when looping over an iterable to take special action on its first
    and/or last items:

    >>> iterable = ['Header', 100, 200, 'Footer']
    >>> total = 0
    >>> for is_first, is_last, item in mark_ends(iterable):
    ...     if is_first:
    ...         continue  # Skip the header
    ...     if is_last:
    ...         continue  # Skip the footer
    ...     total += item
    >>> print(total)
    300
    """
    it = iter(iterable)

    try:
        b = next(it)
    except StopIteration:
        return

    try:
        for i in count():
            a = b
            b = next(it)
            yield i == 0, False, a

    except StopIteration:
        yield i == 0, True, a


def locate(iterable, pred=bool, window_size=None):
    """Yield the index of each item in *iterable* for which *pred* returns
    ``True``.

    *pred* defaults to :func:`bool`, which will select truthy items:

        >>> list(locate([0, 1, 1, 0, 1, 0, 0]))
        [1, 2, 4]

    Set *pred* to a custom function to, e.g., find the indexes for a particular
    item.

        >>> list(locate(['a', 'b', 'c', 'b'], lambda x: x == 'b'))
        [1, 3]

    If *window_size* is given, then the *pred* function will be called with
    that many items. This enables searching for sub-sequences:

        >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
        >>> pred = lambda *args: args == (1, 2, 3)
        >>> list(locate(iterable, pred=pred, window_size=3))
        [1, 5, 9]

    Use with :func:`seekable` to find indexes and then retrieve the associated
    items:

        >>> from itertools import count
        >>> from more_itertools import seekable
        >>> source = (3 * n + 1 if (n % 2) else n // 2 for n in count())
        >>> it = seekable(source)
        >>> pred = lambda x: x > 100
        >>> indexes = locate(it, pred=pred)
        >>> i = next(indexes)
        >>> it.seek(i)
        >>> next(it)
        106

    """
    if window_size is None:
        return compress(count(), map(pred, iterable))

    if window_size < 1:
        raise ValueError('window size must be at least 1')

    it = windowed(iterable, window_size, fillvalue=_marker)
    return compress(count(), starmap(pred, it))


def lstrip(iterable, pred):
    """Yield the items from *iterable*, but strip any from the beginning
    for which *pred* returns ``True``.

    For example, to remove a set of items from the start of an iterable:

        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(lstrip(iterable, pred))
        [1, 2, None, 3, False, None]

    This function is analogous to to :func:`str.lstrip`, and is essentially
    an wrapper for :func:`itertools.dropwhile`.

    """
    return dropwhile(pred, iterable)


def rstrip(iterable, pred):
    """Yield the items from *iterable*, but strip any from the end
    for which *pred* returns ``True``.

    For example, to remove a set of items from the end of an iterable:

        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(rstrip(iterable, pred))
        [None, False, None, 1, 2, None, 3]

    This function is analogous to :func:`str.rstrip`.

    """
    cache = []
    cache_append = cache.append
    cache_clear = cache.clear
    for x in iterable:
        if pred(x):
            cache_append(x)
        else:
            yield from cache
            cache_clear()
            yield x


def strip(iterable, pred):
    """Yield the items from *iterable*, but strip any from the
    beginning and end for which *pred* returns ``True``.

    For example, to remove a set of items from both ends of an iterable:

        >>> iterable = (None, False, None, 1, 2, None, 3, False, None)
        >>> pred = lambda x: x in {None, False, ''}
        >>> list(strip(iterable, pred))
        [1, 2, None, 3]

    This function is analogous to :func:`str.strip`.

    """
    return rstrip(lstrip(iterable, pred), pred)


class islice_extended:
    """An extension of :func:`itertools.islice` that supports negative values
    for *stop*, *start*, and *step*.

        >>> iterable = iter('abcdefgh')
        >>> list(islice_extended(iterable, -4, -1))
        ['e', 'f', 'g']

    Slices with negative values require some caching of *iterable*, but this
    function takes care to minimize the amount of memory required.

    For example, you can use a negative step with an infinite iterator:

        >>> from itertools import count
        >>> list(islice_extended(count(), 110, 99, -2))
        [110, 108, 106, 104, 102, 100]

    You can also use slice notation directly:

        >>> iterable = map(str, count())
        >>> it = islice_extended(iterable)[10:20:2]
        >>> list(it)
        ['10', '12', '14', '16', '18']

    """

    def __init__(self, iterable, *args):
        it = iter(iterable)
        if args:
            self._iterable = _islice_helper(it, slice(*args))
        else:
            self._iterable = it

    def __iter__(self):
        return self

    def __next__(self):
        return next(self._iterable)

    def __getitem__(self, key):
        if isinstance(key, slice):
            return islice_extended(_islice_helper(self._iterable, key))

        raise TypeError('islice_extended.__getitem__ argument must be a slice')


def _islice_helper(it, s):
    start = s.start
    stop = s.stop
    if s.step == 0:
        raise ValueError('step argument must be a non-zero integer or None.')
    step = s.step or 1

    if step > 0:
        start = 0 if (start is None) else start

        if start < 0:
            # Consume all but the last -start items
            cache = deque(enumerate(it, 1), maxlen=-start)
            len_iter = cache[-1][0] if cache else 0

            # Adjust start to be positive
            i = max(len_iter + start, 0)

            # Adjust stop to be positive
            if stop is None:
                j = len_iter
            elif stop >= 0:
                j = min(stop, len_iter)
            else:
                j = max(len_iter + stop, 0)

            # Slice the cache
            n = j - i
            if n <= 0:
                return

            for index, item in islice(cache, 0, n, step):
                yield item
        elif (stop is not None) and (stop < 0):
            # Advance to the start position
            next(islice(it, start, start), None)

            # When stop is negative, we have to carry -stop items while
            # iterating
            cache = deque(islice(it, -stop), maxlen=-stop)

            for index, item in enumerate(it):
                cached_item = cache.popleft()
                if index % step == 0:
                    yield cached_item
                cache.append(item)
        else:
            # When both start and stop are positive we have the normal case
            yield from islice(it, start, stop, step)
    else:
        start = -1 if (start is None) else start

        if (stop is not None) and (stop < 0):
            # Consume all but the last items
            n = -stop - 1
            cache = deque(enumerate(it, 1), maxlen=n)
            len_iter = cache[-1][0] if cache else 0

            # If start and stop are both negative they are comparable and
            # we can just slice. Otherwise we can adjust start to be negative
            # and then slice.
            if start < 0:
                i, j = start, stop
            else:
                i, j = min(start - len_iter, -1), None

            for index, item in list(cache)[i:j:step]:
                yield item
        else:
            # Advance to the stop position
            if stop is not None:
                m = stop + 1
                next(islice(it, m, m), None)

            # stop is positive, so if start is negative they are not comparable
            # and we need the rest of the items.
            if start < 0:
                i = start
                n = None
            # stop is None and start is positive, so we just need items up to
            # the start index.
            elif stop is None:
                i = None
                n = start + 1
            # Both stop and start are positive, so they are comparable.
            else:
                i = None
                n = start - stop
                if n <= 0:
                    return

            cache = list(islice(it, n))

            yield from cache[i::step]


def always_reversible(iterable):
    """An extension of :func:`reversed` that supports all iterables, not
    just those which implement the ``Reversible`` or ``Sequence`` protocols.

        >>> print(*always_reversible(x for x in range(3)))
        2 1 0

    If the iterable is already reversible, this function returns the
    result of :func:`reversed()`. If the iterable is not reversible,
    this function will cache the remaining items in the iterable and
    yield them in reverse order, which may require significant storage.
    """
    try:
        return reversed(iterable)
    except TypeError:
        return reversed(list(iterable))


def consecutive_groups(iterable, ordering=lambda x: x):
    """Yield groups of consecutive items using :func:`itertools.groupby`.
    The *ordering* function determines whether two items are adjacent by
    returning their position.

    By default, the ordering function is the identity function. This is
    suitable for finding runs of numbers:

        >>> iterable = [1, 10, 11, 12, 20, 30, 31, 32, 33, 40]
        >>> for group in consecutive_groups(iterable):
        ...     print(list(group))
        [1]
        [10, 11, 12]
        [20]
        [30, 31, 32, 33]
        [40]

    For finding runs of adjacent letters, try using the :meth:`index` method
    of a string of letters:

        >>> from string import ascii_lowercase
        >>> iterable = 'abcdfgilmnop'
        >>> ordering = ascii_lowercase.index
        >>> for group in consecutive_groups(iterable, ordering):
        ...     print(list(group))
        ['a', 'b', 'c', 'd']
        ['f', 'g']
        ['i']
        ['l', 'm', 'n', 'o', 'p']

    Each group of consecutive items is an iterator that shares it source with
    *iterable*. When an an output group is advanced, the previous group is
    no longer available unless its elements are copied (e.g., into a ``list``).

        >>> iterable = [1, 2, 11, 12, 21, 22]
        >>> saved_groups = []
        >>> for group in consecutive_groups(iterable):
        ...     saved_groups.append(list(group))  # Copy group elements
        >>> saved_groups
        [[1, 2], [11, 12], [21, 22]]

    """
    for k, g in groupby(
        enumerate(iterable), key=lambda x: x[0] - ordering(x[1])
    ):
        yield map(itemgetter(1), g)


def difference(iterable, func=sub, *, initial=None):
    """This function is the inverse of :func:`itertools.accumulate`. By default
    it will compute the first difference of *iterable* using
    :func:`operator.sub`:

        >>> from itertools import accumulate
        >>> iterable = accumulate([0, 1, 2, 3, 4])  # produces 0, 1, 3, 6, 10
        >>> list(difference(iterable))
        [0, 1, 2, 3, 4]

    *func* defaults to :func:`operator.sub`, but other functions can be
    specified. They will be applied as follows::

        A, B, C, D, ... --> A, func(B, A), func(C, B), func(D, C), ...

    For example, to do progressive division:

        >>> iterable = [1, 2, 6, 24, 120]
        >>> func = lambda x, y: x // y
        >>> list(difference(iterable, func))
        [1, 2, 3, 4, 5]

    If the *initial* keyword is set, the first element will be skipped when
    computing successive differences.

        >>> it = [10, 11, 13, 16]  # from accumulate([1, 2, 3], initial=10)
        >>> list(difference(it, initial=10))
        [1, 2, 3]

    """
    a, b = tee(iterable)
    try:
        first = [next(b)]
    except StopIteration:
        return iter([])

    if initial is not None:
        first = []

    return chain(first, starmap(func, zip(b, a)))


class SequenceView(Sequence):
    """Return a read-only view of the sequence object *target*.

    :class:`SequenceView` objects are analogous to Python's built-in
    "dictionary view" types. They provide a dynamic view of a sequence's items,
    meaning that when the sequence updates, so does the view.

        >>> seq = ['0', '1', '2']
        >>> view = SequenceView(seq)
        >>> view
        SequenceView(['0', '1', '2'])
        >>> seq.append('3')
        >>> view
        SequenceView(['0', '1', '2', '3'])

    Sequence views support indexing, slicing, and length queries. They act
    like the underlying sequence, except they don't allow assignment:

        >>> view[1]
        '1'
        >>> view[1:-1]
        ['1', '2']
        >>> len(view)
        4

    Sequence views are useful as an alternative to copying, as they don't
    require (much) extra storage.

    """

    def __init__(self, target):
        if not isinstance(target, Sequence):
            raise TypeError
        self._target = target

    def __getitem__(self, index):
        return self._target[index]

    def __len__(self):
        return len(self._target)

    def __repr__(self):
        return '{}({})'.format(self.__class__.__name__, repr(self._target))


class seekable:
    """Wrap an iterator to allow for seeking backward and forward. This
    progressively caches the items in the source iterable so they can be
    re-visited.

    Call :meth:`seek` with an index to seek to that position in the source
    iterable.

    To "reset" an iterator, seek to ``0``:

        >>> from itertools import count
        >>> it = seekable((str(n) for n in count()))
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> it.seek(0)
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> next(it)
        '3'

    You can also seek forward:

        >>> it = seekable((str(n) for n in range(20)))
        >>> it.seek(10)
        >>> next(it)
        '10'
        >>> it.seek(20)  # Seeking past the end of the source isn't a problem
        >>> list(it)
        []
        >>> it.seek(0)  # Resetting works even after hitting the end
        >>> next(it), next(it), next(it)
        ('0', '1', '2')

    Call :meth:`peek` to look ahead one item without advancing the iterator:

        >>> it = seekable('1234')
        >>> it.peek()
        '1'
        >>> list(it)
        ['1', '2', '3', '4']
        >>> it.peek(default='empty')
        'empty'

    Before the iterator is at its end, calling :func:`bool` on it will return
    ``True``. After it will return ``False``:

        >>> it = seekable('5678')
        >>> bool(it)
        True
        >>> list(it)
        ['5', '6', '7', '8']
        >>> bool(it)
        False

    You may view the contents of the cache with the :meth:`elements` method.
    That returns a :class:`SequenceView`, a view that updates automatically:

        >>> it = seekable((str(n) for n in range(10)))
        >>> next(it), next(it), next(it)
        ('0', '1', '2')
        >>> elements = it.elements()
        >>> elements
        SequenceView(['0', '1', '2'])
        >>> next(it)
        '3'
        >>> elements
        SequenceView(['0', '1', '2', '3'])

    By default, the cache grows as the source iterable progresses, so beware of
    wrapping very large or infinite iterables. Supply *maxlen* to limit the
    size of the cache (this of course limits how far back you can seek).

        >>> from itertools import count
        >>> it = seekable((str(n) for n in count()), maxlen=2)
        >>> next(it), next(it), next(it), next(it)
        ('0', '1', '2', '3')
        >>> list(it.elements())
        ['2', '3']
        >>> it.seek(0)
        >>> next(it), next(it), next(it), next(it)
        ('2', '3', '4', '5')
        >>> next(it)
        '6'

    """

    def __init__(self, iterable, maxlen=None):
        self._source = iter(iterable)
        if maxlen is None:
            self._cache = []
        else:
            self._cache = deque([], maxlen)
        self._index = None

    def __iter__(self):
        return self

    def __next__(self):
        if self._index is not None:
            try:
                item = self._cache[self._index]
            except IndexError:
                self._index = None
            else:
                self._index += 1
                return item

        item = next(self._source)
        self._cache.append(item)
        return item

    def __bool__(self):
        try:
            self.peek()
        except StopIteration:
            return False
        return True

    def peek(self, default=_marker):
        try:
            peeked = next(self)
        except StopIteration:
            if default is _marker:
                raise
            return default
        if self._index is None:
            self._index = len(self._cache)
        self._index -= 1
        return peeked

    def elements(self):
        return SequenceView(self._cache)

    def seek(self, index):
        self._index = index
        remainder = index - len(self._cache)
        if remainder > 0:
            consume(self, remainder)


class run_length:
    """
    :func:`run_length.encode` compresses an iterable with run-length encoding.
    It yields groups of repeated items with the count of how many times they
    were repeated:

        >>> uncompressed = 'abbcccdddd'
        >>> list(run_length.encode(uncompressed))
        [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

    :func:`run_length.decode` decompresses an iterable that was previously
    compressed with run-length encoding. It yields the items of the
    decompressed iterable:

        >>> compressed = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
        >>> list(run_length.decode(compressed))
        ['a', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd', 'd']

    """

    @staticmethod
    def encode(iterable):
        return ((k, ilen(g)) for k, g in groupby(iterable))

    @staticmethod
    def decode(iterable):
        return chain.from_iterable(repeat(k, n) for k, n in iterable)


def exactly_n(iterable, n, predicate=bool):
    """Return ``True`` if exactly ``n`` items in the iterable are ``True``
    according to the *predicate* function.

        >>> exactly_n([True, True, False], 2)
        True
        >>> exactly_n([True, True, False], 1)
        False
        >>> exactly_n([0, 1, 2, 3, 4, 5], 3, lambda x: x < 3)
        True

    The iterable will be advanced until ``n + 1`` truthy items are encountered,
    so avoid calling it on infinite iterables.

    """
    return len(take(n + 1, filter(predicate, iterable))) == n


def circular_shifts(iterable):
    """Return a list of circular shifts of *iterable*.

    >>> circular_shifts(range(4))
    [(0, 1, 2, 3), (1, 2, 3, 0), (2, 3, 0, 1), (3, 0, 1, 2)]
    """
    lst = list(iterable)
    return take(len(lst), windowed(cycle(lst), len(lst)))


def make_decorator(wrapping_func, result_index=0):
    """Return a decorator version of *wrapping_func*, which is a function that
    modifies an iterable. *result_index* is the position in that function's
    signature where the iterable goes.

    This lets you use itertools on the "production end," i.e. at function
    definition. This can augment what the function returns without changing the
    function's code.

    For example, to produce a decorator version of :func:`chunked`:

        >>> from more_itertools import chunked
        >>> chunker = make_decorator(chunked, result_index=0)
        >>> @chunker(3)
        ... def iter_range(n):
        ...     return iter(range(n))
        ...
        >>> list(iter_range(9))
        [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

    To only allow truthy items to be returned:

        >>> truth_serum = make_decorator(filter, result_index=1)
        >>> @truth_serum(bool)
        ... def boolean_test():
        ...     return [0, 1, '', ' ', False, True]
        ...
        >>> list(boolean_test())
        [1, ' ', True]

    The :func:`peekable` and :func:`seekable` wrappers make for practical
    decorators:

        >>> from more_itertools import peekable
        >>> peekable_function = make_decorator(peekable)
        >>> @peekable_function()
        ... def str_range(*args):
        ...     return (str(x) for x in range(*args))
        ...
        >>> it = str_range(1, 20, 2)
        >>> next(it), next(it), next(it)
        ('1', '3', '5')
        >>> it.peek()
        '7'
        >>> next(it)
        '7'

    """
    # See https://sites.google.com/site/bbayles/index/decorator_factory for
    # notes on how this works.
    def decorator(*wrapping_args, **wrapping_kwargs):
        def outer_wrapper(f):
            def inner_wrapper(*args, **kwargs):
                result = f(*args, **kwargs)
                wrapping_args_ = list(wrapping_args)
                wrapping_args_.insert(result_index, result)
                return wrapping_func(*wrapping_args_, **wrapping_kwargs)

            return inner_wrapper

        return outer_wrapper

    return decorator


def map_reduce(iterable, keyfunc, valuefunc=None, reducefunc=None):
    """Return a dictionary that maps the items in *iterable* to categories
    defined by *keyfunc*, transforms them with *valuefunc*, and
    then summarizes them by category with *reducefunc*.

    *valuefunc* defaults to the identity function if it is unspecified.
    If *reducefunc* is unspecified, no summarization takes place:

        >>> keyfunc = lambda x: x.upper()
        >>> result = map_reduce('abbccc', keyfunc)
        >>> sorted(result.items())
        [('A', ['a']), ('B', ['b', 'b']), ('C', ['c', 'c', 'c'])]

    Specifying *valuefunc* transforms the categorized items:

        >>> keyfunc = lambda x: x.upper()
        >>> valuefunc = lambda x: 1
        >>> result = map_reduce('abbccc', keyfunc, valuefunc)
        >>> sorted(result.items())
        [('A', [1]), ('B', [1, 1]), ('C', [1, 1, 1])]

    Specifying *reducefunc* summarizes the categorized items:

        >>> keyfunc = lambda x: x.upper()
        >>> valuefunc = lambda x: 1
        >>> reducefunc = sum
        >>> result = map_reduce('abbccc', keyfunc, valuefunc, reducefunc)
        >>> sorted(result.items())
        [('A', 1), ('B', 2), ('C', 3)]

    You may want to filter the input iterable before applying the map/reduce
    procedure:

        >>> all_items = range(30)
        >>> items = [x for x in all_items if 10 <= x <= 20]  # Filter
        >>> keyfunc = lambda x: x % 2  # Evens map to 0; odds to 1
        >>> categories = map_reduce(items, keyfunc=keyfunc)
        >>> sorted(categories.items())
        [(0, [10, 12, 14, 16, 18, 20]), (1, [11, 13, 15, 17, 19])]
        >>> summaries = map_reduce(items, keyfunc=keyfunc, reducefunc=sum)
        >>> sorted(summaries.items())
        [(0, 90), (1, 75)]

    Note that all items in the iterable are gathered into a list before the
    summarization step, which may require significant storage.

    The returned object is a :obj:`collections.defaultdict` with the
    ``default_factory`` set to ``None``, such that it behaves like a normal
    dictionary.

    """
    valuefunc = (lambda x: x) if (valuefunc is None) else valuefunc

    ret = defaultdict(list)
    for item in iterable:
        key = keyfunc(item)
        value = valuefunc(item)
        ret[key].append(value)

    if reducefunc is not None:
        for key, value_list in ret.items():
            ret[key] = reducefunc(value_list)

    ret.default_factory = None
    return ret


def rlocate(iterable, pred=bool, window_size=None):
    """Yield the index of each item in *iterable* for which *pred* returns
    ``True``, starting from the right and moving left.

    *pred* defaults to :func:`bool`, which will select truthy items:

        >>> list(rlocate([0, 1, 1, 0, 1, 0, 0]))  # Truthy at 1, 2, and 4
        [4, 2, 1]

    Set *pred* to a custom function to, e.g., find the indexes for a particular
    item:

        >>> iterable = iter('abcb')
        >>> pred = lambda x: x == 'b'
        >>> list(rlocate(iterable, pred))
        [3, 1]

    If *window_size* is given, then the *pred* function will be called with
    that many items. This enables searching for sub-sequences:

        >>> iterable = [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
        >>> pred = lambda *args: args == (1, 2, 3)
        >>> list(rlocate(iterable, pred=pred, window_size=3))
        [9, 5, 1]

    Beware, this function won't return anything for infinite iterables.
    If *iterable* is reversible, ``rlocate`` will reverse it and search from
    the right. Otherwise, it will search from the left and return the results
    in reverse order.

    See :func:`locate` to for other example applications.

    """
    if window_size is None:
        try:
            len_iter = len(iterable)
            return (len_iter - i - 1 for i in locate(reversed(iterable), pred))
        except TypeError:
            pass

    return reversed(list(locate(iterable, pred, window_size)))


def replace(iterable, pred, substitutes, count=None, window_size=1):
    """Yield the items from *iterable*, replacing the items for which *pred*
    returns ``True`` with the items from the iterable *substitutes*.

        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1]
        >>> pred = lambda x: x == 0
        >>> substitutes = (2, 3)
        >>> list(replace(iterable, pred, substitutes))
        [1, 1, 2, 3, 1, 1, 2, 3, 1, 1]

    If *count* is given, the number of replacements will be limited:

        >>> iterable = [1, 1, 0, 1, 1, 0, 1, 1, 0]
        >>> pred = lambda x: x == 0
        >>> substitutes = [None]
        >>> list(replace(iterable, pred, substitutes, count=2))
        [1, 1, None, 1, 1, None, 1, 1, 0]

    Use *window_size* to control the number of items passed as arguments to
    *pred*. This allows for locating and replacing subsequences.

        >>> iterable = [0, 1, 2, 5, 0, 1, 2, 5]
        >>> window_size = 3
        >>> pred = lambda *args: args == (0, 1, 2)  # 3 items passed to pred
        >>> substitutes = [3, 4] # Splice in these items
        >>> list(replace(iterable, pred, substitutes, window_size=window_size))
        [3, 4, 5, 3, 4, 5]

    """
    if window_size < 1:
        raise ValueError('window_size must be at least 1')

    # Save the substitutes iterable, since it's used more than once
    substitutes = tuple(substitutes)

    # Add padding such that the number of windows matches the length of the
    # iterable
    it = chain(iterable, [_marker] * (window_size - 1))
    windows = windowed(it, window_size)

    n = 0
    for w in windows:
        # If the current window matches our predicate (and we haven't hit
        # our maximum number of replacements), splice in the substitutes
        # and then consume the following windows that overlap with this one.
        # For example, if the iterable is (0, 1, 2, 3, 4...)
        # and the window size is 2, we have (0, 1), (1, 2), (2, 3)...
        # If the predicate matches on (0, 1), we need to zap (0, 1) and (1, 2)
        if pred(*w):
            if (count is None) or (n < count):
                n += 1
                yield from substitutes
                consume(windows, window_size - 1)
                continue

        # If there was no match (or we've reached the replacement limit),
        # yield the first item from the window.
        if w and (w[0] is not _marker):
            yield w[0]


def partitions(iterable):
    """Yield all possible order-preserving partitions of *iterable*.

    >>> iterable = 'abc'
    >>> for part in partitions(iterable):
    ...     print([''.join(p) for p in part])
    ['abc']
    ['a', 'bc']
    ['ab', 'c']
    ['a', 'b', 'c']

    This is unrelated to :func:`partition`.

    """
    sequence = list(iterable)
    n = len(sequence)
    for i in powerset(range(1, n)):
        yield [sequence[i:j] for i, j in zip((0,) + i, i + (n,))]


def set_partitions(iterable, k=None):
    """
    Yield the set partitions of *iterable* into *k* parts. Set partitions are
    not order-preserving.

    >>> iterable = 'abc'
    >>> for part in set_partitions(iterable, 2):
    ...     print([''.join(p) for p in part])
    ['a', 'bc']
    ['ab', 'c']
    ['b', 'ac']


    If *k* is not given, every set partition is generated.

    >>> iterable = 'abc'
    >>> for part in set_partitions(iterable):
    ...     print([''.join(p) for p in part])
    ['abc']
    ['a', 'bc']
    ['ab', 'c']
    ['b', 'ac']
    ['a', 'b', 'c']

    """
    L = list(iterable)
    n = len(L)
    if k is not None:
        if k < 1:
            raise ValueError(
                "Can't partition in a negative or zero number of groups"
            )
        elif k > n:
            return

    def set_partitions_helper(L, k):
        n = len(L)
        if k == 1:
            yield [L]
        elif n == k:
            yield [[s] for s in L]
        else:
            e, *M = L
            for p in set_partitions_helper(M, k - 1):
                yield [[e], *p]
            for p in set_partitions_helper(M, k):
                for i in range(len(p)):
                    yield p[:i] + [[e] + p[i]] + p[i + 1 :]

    if k is None:
        for k in range(1, n + 1):
            yield from set_partitions_helper(L, k)
    else:
        yield from set_partitions_helper(L, k)


class time_limited:
    """
    Yield items from *iterable* until *limit_seconds* have passed.
    If the time limit expires before all items have been yielded, the
    ``timed_out`` parameter will be set to ``True``.

    >>> from time import sleep
    >>> def generator():
    ...     yield 1
    ...     yield 2
    ...     sleep(0.2)
    ...     yield 3
    >>> iterable = time_limited(0.1, generator())
    >>> list(iterable)
    [1, 2]
    >>> iterable.timed_out
    True

    Note that the time is checked before each item is yielded, and iteration
    stops if  the time elapsed is greater than *limit_seconds*. If your time
    limit is 1 second, but it takes 2 seconds to generate the first item from
    the iterable, the function will run for 2 seconds and not yield anything.

    """

    def __init__(self, limit_seconds, iterable):
        if limit_seconds < 0:
            raise ValueError('limit_seconds must be positive')
        self.limit_seconds = limit_seconds
        self._iterable = iter(iterable)
        self._start_time = monotonic()
        self.timed_out = False

    def __iter__(self):
        return self

    def __next__(self):
        item = next(self._iterable)
        if monotonic() - self._start_time > self.limit_seconds:
            self.timed_out = True
            raise StopIteration

        return item


def only(iterable, default=None, too_long=None):
    """If *iterable* has only one item, return it.
    If it has zero items, return *default*.
    If it has more than one item, raise the exception given by *too_long*,
    which is ``ValueError`` by default.

    >>> only([], default='missing')
    'missing'
    >>> only([1])
    1
    >>> only([1, 2])  # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    ValueError: Expected exactly one item in iterable, but got 1, 2,
     and perhaps more.'
    >>> only([1, 2], too_long=TypeError)  # doctest: +IGNORE_EXCEPTION_DETAIL
    Traceback (most recent call last):
    ...
    TypeError

    Note that :func:`only` attempts to advance *iterable* twice to ensure there
    is only one item.  See :func:`spy` or :func:`peekable` to check
    iterable contents less destructively.
    """
    it = iter(iterable)
    first_value = next(it, default)

    try:
        second_value = next(it)
    except StopIteration:
        pass
    else:
        msg = (
            'Expected exactly one item in iterable, but got {!r}, {!r}, '
            'and perhaps more.'.format(first_value, second_value)
        )
        raise too_long or ValueError(msg)

    return first_value


def ichunked(iterable, n):
    """Break *iterable* into sub-iterables with *n* elements each.
    :func:`ichunked` is like :func:`chunked`, but it yields iterables
    instead of lists.

    If the sub-iterables are read in order, the elements of *iterable*
    won't be stored in memory.
    If they are read out of order, :func:`itertools.tee` is used to cache
    elements as necessary.

    >>> from itertools import count
    >>> all_chunks = ichunked(count(), 4)
    >>> c_1, c_2, c_3 = next(all_chunks), next(all_chunks), next(all_chunks)
    >>> list(c_2)  # c_1's elements have been cached; c_3's haven't been
    [4, 5, 6, 7]
    >>> list(c_1)
    [0, 1, 2, 3]
    >>> list(c_3)
    [8, 9, 10, 11]

    """
    source = iter(iterable)

    while True:
        # Check to see whether we're at the end of the source iterable
        item = next(source, _marker)
        if item is _marker:
            return

        # Clone the source and yield an n-length slice
        source, it = tee(chain([item], source))
        yield islice(it, n)

        # Advance the source iterable
        consume(source, n)


def distinct_combinations(iterable, r):
    """Yield the distinct combinations of *r* items taken from *iterable*.

        >>> list(distinct_combinations([0, 0, 1], 2))
        [(0, 0), (0, 1)]

    Equivalent to ``set(combinations(iterable))``, except duplicates are not
    generated and thrown away. For larger input sequences this is much more
    efficient.

    """
    if r < 0:
        raise ValueError('r must be non-negative')
    elif r == 0:
        yield ()
        return
    pool = tuple(iterable)
    generators = [unique_everseen(enumerate(pool), key=itemgetter(1))]
    current_combo = [None] * r
    level = 0
    while generators:
        try:
            cur_idx, p = next(generators[-1])
        except StopIteration:
            generators.pop()
            level -= 1
            continue
        current_combo[level] = p
        if level + 1 == r:
            yield tuple(current_combo)
        else:
            generators.append(
                unique_everseen(
                    enumerate(pool[cur_idx + 1 :], cur_idx + 1),
                    key=itemgetter(1),
                )
            )
            level += 1


def filter_except(validator, iterable, *exceptions):
    """Yield the items from *iterable* for which the *validator* function does
    not raise one of the specified *exceptions*.

    *validator* is called for each item in *iterable*.
    It should be a function that accepts one argument and raises an exception
    if that item is not valid.

    >>> iterable = ['1', '2', 'three', '4', None]
    >>> list(filter_except(int, iterable, ValueError, TypeError))
    ['1', '2', '4']

    If an exception other than one given by *exceptions* is raised by
    *validator*, it is raised like normal.
    """
    for item in iterable:
        try:
            validator(item)
        except exceptions:
            pass
        else:
            yield item


def map_except(function, iterable, *exceptions):
    """Transform each item from *iterable* with *function* and yield the
    result, unless *function* raises one of the specified *exceptions*.

    *function* is called to transform each item in *iterable*.
    It should be a accept one argument.

    >>> iterable = ['1', '2', 'three', '4', None]
    >>> list(map_except(int, iterable, ValueError, TypeError))
    [1, 2, 4]

    If an exception other than one given by *exceptions* is raised by
    *function*, it is raised like normal.
    """
    for item in iterable:
        try:
            yield function(item)
        except exceptions:
            pass


def _sample_unweighted(iterable, k):
    # Implementation of "Algorithm L" from the 1994 paper by Kim-Hung Li:
    # "Reservoir-Sampling Algorithms of Time Complexity O(n(1+log(N/n)))".

    # Fill up the reservoir (collection of samples) with the first `k` samples
    reservoir = take(k, iterable)

    # Generate random number that's the largest in a sample of k U(0,1) numbers
    # Largest order statistic: https://en.wikipedia.org/wiki/Order_statistic
    W = exp(log(random()) / k)

    # The number of elements to skip before changing the reservoir is a random
    # number with a geometric distribution. Sample it using random() and logs.
    next_index = k + floor(log(random()) / log(1 - W))

    for index, element in enumerate(iterable, k):

        if index == next_index:
            reservoir[randrange(k)] = element
            # The new W is the largest in a sample of k U(0, `old_W`) numbers
            W *= exp(log(random()) / k)
            next_index += floor(log(random()) / log(1 - W)) + 1

    return reservoir


def _sample_weighted(iterable, k, weights):
    # Implementation of "A-ExpJ" from the 2006 paper by Efraimidis et al. :
    # "Weighted random sampling with a reservoir".

    # Log-transform for numerical stability for weights that are small/large
    weight_keys = (log(random()) / weight for weight in weights)

    # Fill up the reservoir (collection of samples) with the first `k`
    # weight-keys and elements, then heapify the list.
    reservoir = take(k, zip(weight_keys, iterable))
    heapify(reservoir)

    # The number of jumps before changing the reservoir is a random variable
    # with an exponential distribution. Sample it using random() and logs.
    smallest_weight_key, _ = reservoir[0]
    weights_to_skip = log(random()) / smallest_weight_key

    for weight, element in zip(weights, iterable):
        if weight >= weights_to_skip:
            # The notation here is consistent with the paper, but we store
            # the weight-keys in log-space for better numerical stability.
            smallest_weight_key, _ = reservoir[0]
            t_w = exp(weight * smallest_weight_key)
            r_2 = uniform(t_w, 1)  # generate U(t_w, 1)
            weight_key = log(r_2) / weight
            heapreplace(reservoir, (weight_key, element))
            smallest_weight_key, _ = reservoir[0]
            weights_to_skip = log(random()) / smallest_weight_key
        else:
            weights_to_skip -= weight

    # Equivalent to [element for weight_key, element in sorted(reservoir)]
    return [heappop(reservoir)[1] for _ in range(k)]


def sample(iterable, k, weights=None):
    """Return a *k*-length list of elements chosen (without replacement)
    from the *iterable*. Like :func:`random.sample`, but works on iterables
    of unknown length.

    >>> iterable = range(100)
    >>> sample(iterable, 5)  # doctest: +SKIP
    [81, 60, 96, 16, 4]

    An iterable with *weights* may also be given:

    >>> iterable = range(100)
    >>> weights = (i * i + 1 for i in range(100))
    >>> sampled = sample(iterable, 5, weights=weights)  # doctest: +SKIP
    [79, 67, 74, 66, 78]

    The algorithm can also be used to generate weighted random permutations.
    The relative weight of each item determines the probability that it
    appears late in the permutation.

    >>> data = "abcdefgh"
    >>> weights = range(1, len(data) + 1)
    >>> sample(data, k=len(data), weights=weights)  # doctest: +SKIP
    ['c', 'a', 'b', 'e', 'g', 'd', 'h', 'f']
    """
    if k == 0:
        return []

    iterable = iter(iterable)
    if weights is None:
        return _sample_unweighted(iterable, k)
    else:
        weights = iter(weights)
        return _sample_weighted(iterable, k, weights)


def is_sorted(iterable, key=None, reverse=False):
    """Returns ``True`` if the items of iterable are in sorted order, and
    ``False`` otherwise. *key* and *reverse* have the same meaning that they do
    in the built-in :func:`sorted` function.

    >>> is_sorted(['1', '2', '3', '4', '5'], key=int)
    True
    >>> is_sorted([5, 4, 3, 1, 2], reverse=True)
    False

    The function returns ``False`` after encountering the first out-of-order
    item. If there are no out-of-order items, the iterable is exhausted.
    """

    compare = lt if reverse else gt
    it = iterable if (key is None) else map(key, iterable)
    return not any(starmap(compare, pairwise(it)))


class AbortThread(BaseException):
    pass


class callback_iter:
    """Convert a function that uses callbacks to an iterator.

    Let *func* be a function that takes a `callback` keyword argument.
    For example:

    >>> def func(callback=None):
    ...     for i, c in [(1, 'a'), (2, 'b'), (3, 'c')]:
    ...         if callback:
    ...             callback(i, c)
    ...     return 4


    Use ``with callback_iter(func)`` to get an iterator over the parameters
    that are delivered to the callback.

    >>> with callback_iter(func) as it:
    ...     for args, kwargs in it:
    ...         print(args)
    (1, 'a')
    (2, 'b')
    (3, 'c')

    The function will be called in a background thread. The ``done`` property
    indicates whether it has completed execution.

    >>> it.done
    True

    If it completes successfully, its return value will be available
    in the ``result`` property.

    >>> it.result
    4

    Notes:

    * If the function uses some keyword argument besides ``callback``, supply
      *callback_kwd*.
    * If it finished executing, but raised an exception, accessing the
      ``result`` property will raise the same exception.
    * If it hasn't finished executing, accessing the ``result``
      property from within the ``with`` block will raise ``RuntimeError``.
    * If it hasn't finished executing, accessing the ``result`` property from
      outside the ``with`` block will raise a
      ``more_itertools.AbortThread`` exception.
    * Provide *wait_seconds* to adjust how frequently the it is polled for
      output.

    """

    def __init__(self, func, callback_kwd='callback', wait_seconds=0.1):
        self._func = func
        self._callback_kwd = callback_kwd
        self._aborted = False
        self._future = None
        self._wait_seconds = wait_seconds
        self._executor = __import__("concurrent.futures").futures.ThreadPoolExecutor(max_workers=1)
        self._iterator = self._reader()

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        self._aborted = True
        self._executor.shutdown()

    def __iter__(self):
        return self

    def __next__(self):
        return next(self._iterator)

    @property
    def done(self):
        if self._future is None:
            return False
        return self._future.done()

    @property
    def result(self):
        if not self.done:
            raise RuntimeError('Function has not yet completed')

        return self._future.result()

    def _reader(self):
        q = Queue()

        def callback(*args, **kwargs):
            if self._aborted:
                raise AbortThread('canceled by user')

            q.put((args, kwargs))

        self._future = self._executor.submit(
            self._func, **{self._callback_kwd: callback}
        )

        while True:
            try:
                item = q.get(timeout=self._wait_seconds)
            except Empty:
                pass
            else:
                q.task_done()
                yield item

            if self._future.done():
                break

        remaining = []
        while True:
            try:
                item = q.get_nowait()
            except Empty:
                break
            else:
                q.task_done()
                remaining.append(item)
        q.join()
        yield from remaining


def windowed_complete(iterable, n):
    """
    Yield ``(beginning, middle, end)`` tuples, where:

    * Each ``middle`` has *n* items from *iterable*
    * Each ``beginning`` has the items before the ones in ``middle``
    * Each ``end`` has the items after the ones in ``middle``

    >>> iterable = range(7)
    >>> n = 3
    >>> for beginning, middle, end in windowed_complete(iterable, n):
    ...     print(beginning, middle, end)
    () (0, 1, 2) (3, 4, 5, 6)
    (0,) (1, 2, 3) (4, 5, 6)
    (0, 1) (2, 3, 4) (5, 6)
    (0, 1, 2) (3, 4, 5) (6,)
    (0, 1, 2, 3) (4, 5, 6) ()

    Note that *n* must be at least 0 and most equal to the length of
    *iterable*.

    This function will exhaust the iterable and may require significant
    storage.
    """
    if n < 0:
        raise ValueError('n must be >= 0')

    seq = tuple(iterable)
    size = len(seq)

    if n > size:
        raise ValueError('n must be <= len(seq)')

    for i in range(size - n + 1):
        beginning = seq[:i]
        middle = seq[i : i + n]
        end = seq[i + n :]
        yield beginning, middle, end


def all_unique(iterable, key=None):
    """
    Returns ``True`` if all the elements of *iterable* are unique (no two
    elements are equal).

        >>> all_unique('ABCB')
        False

    If a *key* function is specified, it will be used to make comparisons.

        >>> all_unique('ABCb')
        True
        >>> all_unique('ABCb', str.lower)
        False

    The function returns as soon as the first non-unique element is
    encountered. Iterables with a mix of hashable and unhashable items can
    be used, but the function will be slower for unhashable items.
    """
    seenset = set()
    seenset_add = seenset.add
    seenlist = []
    seenlist_add = seenlist.append
    for element in map(key, iterable) if key else iterable:
        try:
            if element in seenset:
                return False
            seenset_add(element)
        except TypeError:
            if element in seenlist:
                return False
            seenlist_add(element)
    return True


def nth_product(index, *args):
    """Equivalent to ``list(product(*args))[index]``.

    The products of *args* can be ordered lexicographically.
    :func:`nth_product` computes the product at sort position *index* without
    computing the previous products.

        >>> nth_product(8, range(2), range(2), range(2), range(2))
        (1, 0, 0, 0)

    ``IndexError`` will be raised if the given *index* is invalid.
    """
    pools = list(map(tuple, reversed(args)))
    ns = list(map(len, pools))

    c = reduce(mul, ns)

    if index < 0:
        index += c

    if not 0 <= index < c:
        raise IndexError

    result = []
    for pool, n in zip(pools, ns):
        result.append(pool[index % n])
        index //= n

    return tuple(reversed(result))


def nth_permutation(iterable, r, index):
    """Equivalent to ``list(permutations(iterable, r))[index]```

    The subsequences of *iterable* that are of length *r* where order is
    important can be ordered lexicographically. :func:`nth_permutation`
    computes the subsequence at sort position *index* directly, without
    computing the previous subsequences.

        >>> nth_permutation('ghijk', 2, 5)
        ('h', 'i')

    ``ValueError`` will be raised If *r* is negative or greater than the length
    of *iterable*.
    ``IndexError`` will be raised if the given *index* is invalid.
    """
    pool = list(iterable)
    n = len(pool)

    if r is None or r == n:
        r, c = n, factorial(n)
    elif not 0 <= r < n:
        raise ValueError
    else:
        c = factorial(n) // factorial(n - r)

    if index < 0:
        index += c

    if not 0 <= index < c:
        raise IndexError

    if c == 0:
        return tuple()

    result = [0] * r
    q = index * factorial(n) // c if r < n else index
    for d in range(1, n + 1):
        q, i = divmod(q, d)
        if 0 <= n - d < r:
            result[n - d] = i
        if q == 0:
            break

    return tuple(map(pool.pop, result))


def value_chain(*args):
    """Yield all arguments passed to the function in the same order in which
    they were passed. If an argument itself is iterable then iterate over its
    values.

        >>> list(value_chain(1, 2, 3, [4, 5, 6]))
        [1, 2, 3, 4, 5, 6]

    Binary and text strings are not considered iterable and are emitted
    as-is:

        >>> list(value_chain('12', '34', ['56', '78']))
        ['12', '34', '56', '78']


    Multiple levels of nesting are not flattened.

    """
    for value in args:
        if isinstance(value, (str, bytes)):
            yield value
            continue
        try:
            yield from value
        except TypeError:
            yield value


def product_index(element, *args):
    """Equivalent to ``list(product(*args)).index(element)``

    The products of *args* can be ordered lexicographically.
    :func:`product_index` computes the first index of *element* without
    computing the previous products.

        >>> product_index([8, 2], range(10), range(5))
        42

    ``ValueError`` will be raised if the given *element* isn't in the product
    of *args*.
    """
    index = 0

    for x, pool in zip_longest(element, args, fillvalue=_marker):
        if x is _marker or pool is _marker:
            raise ValueError('element is not a product of args')

        pool = tuple(pool)
        index = index * len(pool) + pool.index(x)

    return index


def combination_index(element, iterable):
    """Equivalent to ``list(combinations(iterable, r)).index(element)``

    The subsequences of *iterable* that are of length *r* can be ordered
    lexicographically. :func:`combination_index` computes the index of the
    first *element*, without computing the previous combinations.

        >>> combination_index('adf', 'abcdefg')
        10

    ``ValueError`` will be raised if the given *element* isn't one of the
    combinations of *iterable*.
    """
    element = enumerate(element)
    k, y = next(element, (None, None))
    if k is None:
        return 0

    indexes = []
    pool = enumerate(iterable)
    for n, x in pool:
        if x == y:
            indexes.append(n)
            tmp, y = next(element, (None, None))
            if tmp is None:
                break
            else:
                k = tmp
    else:
        raise ValueError('element is not a combination of iterable')

    n, _ = last(pool, default=(n, None))

    # Python versiosn below 3.8 don't have math.comb
    index = 1
    for i, j in enumerate(reversed(indexes), start=1):
        j = n - j
        if i <= j:
            index += factorial(j) // (factorial(i) * factorial(j - i))

    return factorial(n + 1) // (factorial(k + 1) * factorial(n - k)) - index


def permutation_index(element, iterable):
    """Equivalent to ``list(permutations(iterable, r)).index(element)```

    The subsequences of *iterable* that are of length *r* where order is
    important can be ordered lexicographically. :func:`permutation_index`
    computes the index of the first *element* directly, without computing
    the previous permutations.

        >>> permutation_index([1, 3, 2], range(5))
        19

    ``ValueError`` will be raised if the given *element* isn't one of the
    permutations of *iterable*.
    """
    index = 0
    pool = list(iterable)
    for i, x in zip(range(len(pool), -1, -1), element):
        r = pool.index(x)
        index = index * i + r
        del pool[r]

    return index


class countable:
    """Wrap *iterable* and keep a count of how many items have been consumed.

    The ``items_seen`` attribute starts at ``0`` and increments as the iterable
    is consumed:

        >>> iterable = map(str, range(10))
        >>> it = countable(iterable)
        >>> it.items_seen
        0
        >>> next(it), next(it)
        ('0', '1')
        >>> list(it)
        ['2', '3', '4', '5', '6', '7', '8', '9']
        >>> it.items_seen
        10
    """

    def __init__(self, iterable):
        self._it = iter(iterable)
        self.items_seen = 0

    def __iter__(self):
        return self

    def __next__(self):
        item = next(self._it)
        self.items_seen += 1

        return item
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/more_itertools/recipes.py0000644000175100001730000003760014467657412024407 0ustar00runnerdocker"""Imported from the recipes section of the itertools documentation.

All functions taken from the recipes section of the itertools library docs
[1]_.
Some backward-compatible usability improvements have been made.

.. [1] http://docs.python.org/library/itertools.html#recipes

"""
import warnings
from collections import deque
from itertools import (
    chain,
    combinations,
    count,
    cycle,
    groupby,
    islice,
    repeat,
    starmap,
    tee,
    zip_longest,
)
import operator
from random import randrange, sample, choice

__all__ = [
    'all_equal',
    'consume',
    'convolve',
    'dotproduct',
    'first_true',
    'flatten',
    'grouper',
    'iter_except',
    'ncycles',
    'nth',
    'nth_combination',
    'padnone',
    'pad_none',
    'pairwise',
    'partition',
    'powerset',
    'prepend',
    'quantify',
    'random_combination_with_replacement',
    'random_combination',
    'random_permutation',
    'random_product',
    'repeatfunc',
    'roundrobin',
    'tabulate',
    'tail',
    'take',
    'unique_everseen',
    'unique_justseen',
]


def take(n, iterable):
    """Return first *n* items of the iterable as a list.

        >>> take(3, range(10))
        [0, 1, 2]

    If there are fewer than *n* items in the iterable, all of them are
    returned.

        >>> take(10, range(3))
        [0, 1, 2]

    """
    return list(islice(iterable, n))


def tabulate(function, start=0):
    """Return an iterator over the results of ``func(start)``,
    ``func(start + 1)``, ``func(start + 2)``...

    *func* should be a function that accepts one integer argument.

    If *start* is not specified it defaults to 0. It will be incremented each
    time the iterator is advanced.

        >>> square = lambda x: x ** 2
        >>> iterator = tabulate(square, -3)
        >>> take(4, iterator)
        [9, 4, 1, 0]

    """
    return map(function, count(start))


def tail(n, iterable):
    """Return an iterator over the last *n* items of *iterable*.

    >>> t = tail(3, 'ABCDEFG')
    >>> list(t)
    ['E', 'F', 'G']

    """
    return iter(deque(iterable, maxlen=n))


def consume(iterator, n=None):
    """Advance *iterable* by *n* steps. If *n* is ``None``, consume it
    entirely.

    Efficiently exhausts an iterator without returning values. Defaults to
    consuming the whole iterator, but an optional second argument may be
    provided to limit consumption.

        >>> i = (x for x in range(10))
        >>> next(i)
        0
        >>> consume(i, 3)
        >>> next(i)
        4
        >>> consume(i)
        >>> next(i)
        Traceback (most recent call last):
          File "", line 1, in 
        StopIteration

    If the iterator has fewer items remaining than the provided limit, the
    whole iterator will be consumed.

        >>> i = (x for x in range(3))
        >>> consume(i, 5)
        >>> next(i)
        Traceback (most recent call last):
          File "", line 1, in 
        StopIteration

    """
    # Use functions that consume iterators at C speed.
    if n is None:
        # feed the entire iterator into a zero-length deque
        deque(iterator, maxlen=0)
    else:
        # advance to the empty slice starting at position n
        next(islice(iterator, n, n), None)


def nth(iterable, n, default=None):
    """Returns the nth item or a default value.

    >>> l = range(10)
    >>> nth(l, 3)
    3
    >>> nth(l, 20, "zebra")
    'zebra'

    """
    return next(islice(iterable, n, None), default)


def all_equal(iterable):
    """
    Returns ``True`` if all the elements are equal to each other.

        >>> all_equal('aaaa')
        True
        >>> all_equal('aaab')
        False

    """
    g = groupby(iterable)
    return next(g, True) and not next(g, False)


def quantify(iterable, pred=bool):
    """Return the how many times the predicate is true.

    >>> quantify([True, False, True])
    2

    """
    return sum(map(pred, iterable))


def pad_none(iterable):
    """Returns the sequence of elements and then returns ``None`` indefinitely.

        >>> take(5, pad_none(range(3)))
        [0, 1, 2, None, None]

    Useful for emulating the behavior of the built-in :func:`map` function.

    See also :func:`padded`.

    """
    return chain(iterable, repeat(None))


padnone = pad_none


def ncycles(iterable, n):
    """Returns the sequence elements *n* times

    >>> list(ncycles(["a", "b"], 3))
    ['a', 'b', 'a', 'b', 'a', 'b']

    """
    return chain.from_iterable(repeat(tuple(iterable), n))


def dotproduct(vec1, vec2):
    """Returns the dot product of the two iterables.

    >>> dotproduct([10, 10], [20, 20])
    400

    """
    return sum(map(operator.mul, vec1, vec2))


def flatten(listOfLists):
    """Return an iterator flattening one level of nesting in a list of lists.

        >>> list(flatten([[0, 1], [2, 3]]))
        [0, 1, 2, 3]

    See also :func:`collapse`, which can flatten multiple levels of nesting.

    """
    return chain.from_iterable(listOfLists)


def repeatfunc(func, times=None, *args):
    """Call *func* with *args* repeatedly, returning an iterable over the
    results.

    If *times* is specified, the iterable will terminate after that many
    repetitions:

        >>> from operator import add
        >>> times = 4
        >>> args = 3, 5
        >>> list(repeatfunc(add, times, *args))
        [8, 8, 8, 8]

    If *times* is ``None`` the iterable will not terminate:

        >>> from random import randrange
        >>> times = None
        >>> args = 1, 11
        >>> take(6, repeatfunc(randrange, times, *args))  # doctest:+SKIP
        [2, 4, 8, 1, 8, 4]

    """
    if times is None:
        return starmap(func, repeat(args))
    return starmap(func, repeat(args, times))


def _pairwise(iterable):
    """Returns an iterator of paired items, overlapping, from the original

    >>> take(4, pairwise(count()))
    [(0, 1), (1, 2), (2, 3), (3, 4)]

    On Python 3.10 and above, this is an alias for :func:`itertools.pairwise`.

    """
    a, b = tee(iterable)
    next(b, None)
    yield from zip(a, b)


try:
    from itertools import pairwise as itertools_pairwise
except ImportError:
    pairwise = _pairwise
else:

    def pairwise(iterable):
        yield from itertools_pairwise(iterable)

    pairwise.__doc__ = _pairwise.__doc__


def grouper(iterable, n, fillvalue=None):
    """Collect data into fixed-length chunks or blocks.

    >>> list(grouper('ABCDEFG', 3, 'x'))
    [('A', 'B', 'C'), ('D', 'E', 'F'), ('G', 'x', 'x')]

    """
    if isinstance(iterable, int):
        warnings.warn(
            "grouper expects iterable as first parameter", DeprecationWarning
        )
        n, iterable = iterable, n
    args = [iter(iterable)] * n
    return zip_longest(fillvalue=fillvalue, *args)


def roundrobin(*iterables):
    """Yields an item from each iterable, alternating between them.

        >>> list(roundrobin('ABC', 'D', 'EF'))
        ['A', 'D', 'E', 'B', 'F', 'C']

    This function produces the same output as :func:`interleave_longest`, but
    may perform better for some inputs (in particular when the number of
    iterables is small).

    """
    # Recipe credited to George Sakkis
    pending = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while pending:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            pending -= 1
            nexts = cycle(islice(nexts, pending))


def partition(pred, iterable):
    """
    Returns a 2-tuple of iterables derived from the input iterable.
    The first yields the items that have ``pred(item) == False``.
    The second yields the items that have ``pred(item) == True``.

        >>> is_odd = lambda x: x % 2 != 0
        >>> iterable = range(10)
        >>> even_items, odd_items = partition(is_odd, iterable)
        >>> list(even_items), list(odd_items)
        ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])

    If *pred* is None, :func:`bool` is used.

        >>> iterable = [0, 1, False, True, '', ' ']
        >>> false_items, true_items = partition(None, iterable)
        >>> list(false_items), list(true_items)
        ([0, False, ''], [1, True, ' '])

    """
    if pred is None:
        pred = bool

    evaluations = ((pred(x), x) for x in iterable)
    t1, t2 = tee(evaluations)
    return (
        (x for (cond, x) in t1 if not cond),
        (x for (cond, x) in t2 if cond),
    )


def powerset(iterable):
    """Yields all possible subsets of the iterable.

        >>> list(powerset([1, 2, 3]))
        [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

    :func:`powerset` will operate on iterables that aren't :class:`set`
    instances, so repeated elements in the input will produce repeated elements
    in the output. Use :func:`unique_everseen` on the input to avoid generating
    duplicates:

        >>> seq = [1, 1, 0]
        >>> list(powerset(seq))
        [(), (1,), (1,), (0,), (1, 1), (1, 0), (1, 0), (1, 1, 0)]
        >>> from more_itertools import unique_everseen
        >>> list(powerset(unique_everseen(seq)))
        [(), (1,), (0,), (1, 0)]

    """
    s = list(iterable)
    return chain.from_iterable(combinations(s, r) for r in range(len(s) + 1))


def unique_everseen(iterable, key=None):
    """
    Yield unique elements, preserving order.

        >>> list(unique_everseen('AAAABBBCCDAABBB'))
        ['A', 'B', 'C', 'D']
        >>> list(unique_everseen('ABBCcAD', str.lower))
        ['A', 'B', 'C', 'D']

    Sequences with a mix of hashable and unhashable items can be used.
    The function will be slower (i.e., `O(n^2)`) for unhashable items.

    Remember that ``list`` objects are unhashable - you can use the *key*
    parameter to transform the list to a tuple (which is hashable) to
    avoid a slowdown.

        >>> iterable = ([1, 2], [2, 3], [1, 2])
        >>> list(unique_everseen(iterable))  # Slow
        [[1, 2], [2, 3]]
        >>> list(unique_everseen(iterable, key=tuple))  # Faster
        [[1, 2], [2, 3]]

    Similary, you may want to convert unhashable ``set`` objects with
    ``key=frozenset``. For ``dict`` objects,
    ``key=lambda x: frozenset(x.items())`` can be used.

    """
    seenset = set()
    seenset_add = seenset.add
    seenlist = []
    seenlist_add = seenlist.append
    use_key = key is not None

    for element in iterable:
        k = key(element) if use_key else element
        try:
            if k not in seenset:
                seenset_add(k)
                yield element
        except TypeError:
            if k not in seenlist:
                seenlist_add(k)
                yield element


def unique_justseen(iterable, key=None):
    """Yields elements in order, ignoring serial duplicates

    >>> list(unique_justseen('AAAABBBCCDAABBB'))
    ['A', 'B', 'C', 'D', 'A', 'B']
    >>> list(unique_justseen('ABBCcAD', str.lower))
    ['A', 'B', 'C', 'A', 'D']

    """
    return map(next, map(operator.itemgetter(1), groupby(iterable, key)))


def iter_except(func, exception, first=None):
    """Yields results from a function repeatedly until an exception is raised.

    Converts a call-until-exception interface to an iterator interface.
    Like ``iter(func, sentinel)``, but uses an exception instead of a sentinel
    to end the loop.

        >>> l = [0, 1, 2]
        >>> list(iter_except(l.pop, IndexError))
        [2, 1, 0]

    """
    try:
        if first is not None:
            yield first()
        while 1:
            yield func()
    except exception:
        pass


def first_true(iterable, default=None, pred=None):
    """
    Returns the first true value in the iterable.

    If no true value is found, returns *default*

    If *pred* is not None, returns the first item for which
    ``pred(item) == True`` .

        >>> first_true(range(10))
        1
        >>> first_true(range(10), pred=lambda x: x > 5)
        6
        >>> first_true(range(10), default='missing', pred=lambda x: x > 9)
        'missing'

    """
    return next(filter(pred, iterable), default)


def random_product(*args, repeat=1):
    """Draw an item at random from each of the input iterables.

        >>> random_product('abc', range(4), 'XYZ')  # doctest:+SKIP
        ('c', 3, 'Z')

    If *repeat* is provided as a keyword argument, that many items will be
    drawn from each iterable.

        >>> random_product('abcd', range(4), repeat=2)  # doctest:+SKIP
        ('a', 2, 'd', 3)

    This equivalent to taking a random selection from
    ``itertools.product(*args, **kwarg)``.

    """
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(choice(pool) for pool in pools)


def random_permutation(iterable, r=None):
    """Return a random *r* length permutation of the elements in *iterable*.

    If *r* is not specified or is ``None``, then *r* defaults to the length of
    *iterable*.

        >>> random_permutation(range(5))  # doctest:+SKIP
        (3, 4, 0, 1, 2)

    This equivalent to taking a random selection from
    ``itertools.permutations(iterable, r)``.

    """
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(sample(pool, r))


def random_combination(iterable, r):
    """Return a random *r* length subsequence of the elements in *iterable*.

        >>> random_combination(range(5), 3)  # doctest:+SKIP
        (2, 3, 4)

    This equivalent to taking a random selection from
    ``itertools.combinations(iterable, r)``.

    """
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(sample(range(n), r))
    return tuple(pool[i] for i in indices)


def random_combination_with_replacement(iterable, r):
    """Return a random *r* length subsequence of elements in *iterable*,
    allowing individual elements to be repeated.

        >>> random_combination_with_replacement(range(3), 5) # doctest:+SKIP
        (0, 0, 1, 2, 2)

    This equivalent to taking a random selection from
    ``itertools.combinations_with_replacement(iterable, r)``.

    """
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(randrange(n) for i in range(r))
    return tuple(pool[i] for i in indices)


def nth_combination(iterable, r, index):
    """Equivalent to ``list(combinations(iterable, r))[index]``.

    The subsequences of *iterable* that are of length *r* can be ordered
    lexicographically. :func:`nth_combination` computes the subsequence at
    sort position *index* directly, without computing the previous
    subsequences.

        >>> nth_combination(range(5), 3, 5)
        (0, 3, 4)

    ``ValueError`` will be raised If *r* is negative or greater than the length
    of *iterable*.
    ``IndexError`` will be raised if the given *index* is invalid.
    """
    pool = tuple(iterable)
    n = len(pool)
    if (r < 0) or (r > n):
        raise ValueError

    c = 1
    k = min(r, n - r)
    for i in range(1, k + 1):
        c = c * (n - k + i) // i

    if index < 0:
        index += c

    if (index < 0) or (index >= c):
        raise IndexError

    result = []
    while r:
        c, n, r = c * r // n, n - 1, r - 1
        while index >= c:
            index -= c
            c, n = c * (n - r) // n, n - 1
        result.append(pool[-1 - n])

    return tuple(result)


def prepend(value, iterator):
    """Yield *value*, followed by the elements in *iterator*.

        >>> value = '0'
        >>> iterator = ['1', '2', '3']
        >>> list(prepend(value, iterator))
        ['0', '1', '2', '3']

    To prepend multiple values, see :func:`itertools.chain`
    or :func:`value_chain`.

    """
    return chain([value], iterator)


def convolve(signal, kernel):
    """Convolve the iterable *signal* with the iterable *kernel*.

        >>> signal = (1, 2, 3, 4, 5)
        >>> kernel = [3, 2, 1]
        >>> list(convolve(signal, kernel))
        [3, 8, 14, 20, 26, 14, 5]

    Note: the input arguments are not interchangeable, as the *kernel*
    is immediately consumed and stored.

    """
    kernel = tuple(kernel)[::-1]
    n = len(kernel)
    window = deque([0], maxlen=n) * n
    for x in chain(signal, repeat(0, n - 1)):
        window.append(x)
        yield sum(map(operator.mul, kernel, window))
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/more_itertools-8.8.0.dist-info/0000755000175100001730000000000014467657444024746 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/more_itertools-8.8.0.dist-info/top_level.txt0000644000175100001730000000001714467657412027471 0ustar00runnerdockermore_itertools
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/ordered_set-3.1.1.dist-info/0000755000175100001730000000000014467657444024164 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/ordered_set-3.1.1.dist-info/top_level.txt0000644000175100001730000000001414467657412026704 0ustar00runnerdockerordered_set
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/ordered_set.py0000644000175100001730000003543214467657412022207 0ustar00runnerdocker"""
An OrderedSet is a custom MutableSet that remembers its order, so that every
entry has an index that can be looked up.

Based on a recipe originally posted to ActiveState Recipes by Raymond Hettiger,
and released under the MIT license.
"""
import itertools as it
from collections import deque

try:
    # Python 3
    from collections.abc import MutableSet, Sequence
except ImportError:
    # Python 2.7
    from collections import MutableSet, Sequence

SLICE_ALL = slice(None)
__version__ = "3.1"


def is_iterable(obj):
    """
    Are we being asked to look up a list of things, instead of a single thing?
    We check for the `__iter__` attribute so that this can cover types that
    don't have to be known by this module, such as NumPy arrays.

    Strings, however, should be considered as atomic values to look up, not
    iterables. The same goes for tuples, since they are immutable and therefore
    valid entries.

    We don't need to check for the Python 2 `unicode` type, because it doesn't
    have an `__iter__` attribute anyway.
    """
    return (
        hasattr(obj, "__iter__")
        and not isinstance(obj, str)
        and not isinstance(obj, tuple)
    )


class OrderedSet(MutableSet, Sequence):
    """
    An OrderedSet is a custom MutableSet that remembers its order, so that
    every entry has an index that can be looked up.

    Example:
        >>> OrderedSet([1, 1, 2, 3, 2])
        OrderedSet([1, 2, 3])
    """

    def __init__(self, iterable=None):
        self.items = []
        self.map = {}
        if iterable is not None:
            self |= iterable

    def __len__(self):
        """
        Returns the number of unique elements in the ordered set

        Example:
            >>> len(OrderedSet([]))
            0
            >>> len(OrderedSet([1, 2]))
            2
        """
        return len(self.items)

    def __getitem__(self, index):
        """
        Get the item at a given index.

        If `index` is a slice, you will get back that slice of items, as a
        new OrderedSet.

        If `index` is a list or a similar iterable, you'll get a list of
        items corresponding to those indices. This is similar to NumPy's
        "fancy indexing". The result is not an OrderedSet because you may ask
        for duplicate indices, and the number of elements returned should be
        the number of elements asked for.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset[1]
            2
        """
        if isinstance(index, slice) and index == SLICE_ALL:
            return self.copy()
        elif is_iterable(index):
            return [self.items[i] for i in index]
        elif hasattr(index, "__index__") or isinstance(index, slice):
            result = self.items[index]
            if isinstance(result, list):
                return self.__class__(result)
            else:
                return result
        else:
            raise TypeError("Don't know how to index an OrderedSet by %r" % index)

    def copy(self):
        """
        Return a shallow copy of this object.

        Example:
            >>> this = OrderedSet([1, 2, 3])
            >>> other = this.copy()
            >>> this == other
            True
            >>> this is other
            False
        """
        return self.__class__(self)

    def __getstate__(self):
        if len(self) == 0:
            # The state can't be an empty list.
            # We need to return a truthy value, or else __setstate__ won't be run.
            #
            # This could have been done more gracefully by always putting the state
            # in a tuple, but this way is backwards- and forwards- compatible with
            # previous versions of OrderedSet.
            return (None,)
        else:
            return list(self)

    def __setstate__(self, state):
        if state == (None,):
            self.__init__([])
        else:
            self.__init__(state)

    def __contains__(self, key):
        """
        Test if the item is in this ordered set

        Example:
            >>> 1 in OrderedSet([1, 3, 2])
            True
            >>> 5 in OrderedSet([1, 3, 2])
            False
        """
        return key in self.map

    def add(self, key):
        """
        Add `key` as an item to this OrderedSet, then return its index.

        If `key` is already in the OrderedSet, return the index it already
        had.

        Example:
            >>> oset = OrderedSet()
            >>> oset.append(3)
            0
            >>> print(oset)
            OrderedSet([3])
        """
        if key not in self.map:
            self.map[key] = len(self.items)
            self.items.append(key)
        return self.map[key]

    append = add

    def update(self, sequence):
        """
        Update the set with the given iterable sequence, then return the index
        of the last element inserted.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.update([3, 1, 5, 1, 4])
            4
            >>> print(oset)
            OrderedSet([1, 2, 3, 5, 4])
        """
        item_index = None
        try:
            for item in sequence:
                item_index = self.add(item)
        except TypeError:
            raise ValueError(
                "Argument needs to be an iterable, got %s" % type(sequence)
            )
        return item_index

    def index(self, key):
        """
        Get the index of a given entry, raising an IndexError if it's not
        present.

        `key` can be an iterable of entries that is not a string, in which case
        this returns a list of indices.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.index(2)
            1
        """
        if is_iterable(key):
            return [self.index(subkey) for subkey in key]
        return self.map[key]

    # Provide some compatibility with pd.Index
    get_loc = index
    get_indexer = index

    def pop(self):
        """
        Remove and return the last element from the set.

        Raises KeyError if the set is empty.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.pop()
            3
        """
        if not self.items:
            raise KeyError("Set is empty")

        elem = self.items[-1]
        del self.items[-1]
        del self.map[elem]
        return elem

    def discard(self, key):
        """
        Remove an element.  Do not raise an exception if absent.

        The MutableSet mixin uses this to implement the .remove() method, which
        *does* raise an error when asked to remove a non-existent item.

        Example:
            >>> oset = OrderedSet([1, 2, 3])
            >>> oset.discard(2)
            >>> print(oset)
            OrderedSet([1, 3])
            >>> oset.discard(2)
            >>> print(oset)
            OrderedSet([1, 3])
        """
        if key in self:
            i = self.map[key]
            del self.items[i]
            del self.map[key]
            for k, v in self.map.items():
                if v >= i:
                    self.map[k] = v - 1

    def clear(self):
        """
        Remove all items from this OrderedSet.
        """
        del self.items[:]
        self.map.clear()

    def __iter__(self):
        """
        Example:
            >>> list(iter(OrderedSet([1, 2, 3])))
            [1, 2, 3]
        """
        return iter(self.items)

    def __reversed__(self):
        """
        Example:
            >>> list(reversed(OrderedSet([1, 2, 3])))
            [3, 2, 1]
        """
        return reversed(self.items)

    def __repr__(self):
        if not self:
            return "%s()" % (self.__class__.__name__,)
        return "%s(%r)" % (self.__class__.__name__, list(self))

    def __eq__(self, other):
        """
        Returns true if the containers have the same items. If `other` is a
        Sequence, then order is checked, otherwise it is ignored.

        Example:
            >>> oset = OrderedSet([1, 3, 2])
            >>> oset == [1, 3, 2]
            True
            >>> oset == [1, 2, 3]
            False
            >>> oset == [2, 3]
            False
            >>> oset == OrderedSet([3, 2, 1])
            False
        """
        # In Python 2 deque is not a Sequence, so treat it as one for
        # consistent behavior with Python 3.
        if isinstance(other, (Sequence, deque)):
            # Check that this OrderedSet contains the same elements, in the
            # same order, as the other object.
            return list(self) == list(other)
        try:
            other_as_set = set(other)
        except TypeError:
            # If `other` can't be converted into a set, it's not equal.
            return False
        else:
            return set(self) == other_as_set

    def union(self, *sets):
        """
        Combines all unique items.
        Each items order is defined by its first appearance.

        Example:
            >>> oset = OrderedSet.union(OrderedSet([3, 1, 4, 1, 5]), [1, 3], [2, 0])
            >>> print(oset)
            OrderedSet([3, 1, 4, 5, 2, 0])
            >>> oset.union([8, 9])
            OrderedSet([3, 1, 4, 5, 2, 0, 8, 9])
            >>> oset | {10}
            OrderedSet([3, 1, 4, 5, 2, 0, 10])
        """
        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
        containers = map(list, it.chain([self], sets))
        items = it.chain.from_iterable(containers)
        return cls(items)

    def __and__(self, other):
        # the parent implementation of this is backwards
        return self.intersection(other)

    def intersection(self, *sets):
        """
        Returns elements in common between all sets. Order is defined only
        by the first set.

        Example:
            >>> oset = OrderedSet.intersection(OrderedSet([0, 1, 2, 3]), [1, 2, 3])
            >>> print(oset)
            OrderedSet([1, 2, 3])
            >>> oset.intersection([2, 4, 5], [1, 2, 3, 4])
            OrderedSet([2])
            >>> oset.intersection()
            OrderedSet([1, 2, 3])
        """
        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
        if sets:
            common = set.intersection(*map(set, sets))
            items = (item for item in self if item in common)
        else:
            items = self
        return cls(items)

    def difference(self, *sets):
        """
        Returns all elements that are in this set but not the others.

        Example:
            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]))
            OrderedSet([1, 3])
            >>> OrderedSet([1, 2, 3]).difference(OrderedSet([2]), OrderedSet([3]))
            OrderedSet([1])
            >>> OrderedSet([1, 2, 3]) - OrderedSet([2])
            OrderedSet([1, 3])
            >>> OrderedSet([1, 2, 3]).difference()
            OrderedSet([1, 2, 3])
        """
        cls = self.__class__
        if sets:
            other = set.union(*map(set, sets))
            items = (item for item in self if item not in other)
        else:
            items = self
        return cls(items)

    def issubset(self, other):
        """
        Report whether another set contains this set.

        Example:
            >>> OrderedSet([1, 2, 3]).issubset({1, 2})
            False
            >>> OrderedSet([1, 2, 3]).issubset({1, 2, 3, 4})
            True
            >>> OrderedSet([1, 2, 3]).issubset({1, 4, 3, 5})
            False
        """
        if len(self) > len(other):  # Fast check for obvious cases
            return False
        return all(item in other for item in self)

    def issuperset(self, other):
        """
        Report whether this set contains another set.

        Example:
            >>> OrderedSet([1, 2]).issuperset([1, 2, 3])
            False
            >>> OrderedSet([1, 2, 3, 4]).issuperset({1, 2, 3})
            True
            >>> OrderedSet([1, 4, 3, 5]).issuperset({1, 2, 3})
            False
        """
        if len(self) < len(other):  # Fast check for obvious cases
            return False
        return all(item in self for item in other)

    def symmetric_difference(self, other):
        """
        Return the symmetric difference of two OrderedSets as a new set.
        That is, the new set will contain all elements that are in exactly
        one of the sets.

        Their order will be preserved, with elements from `self` preceding
        elements from `other`.

        Example:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.symmetric_difference(other)
            OrderedSet([4, 5, 9, 2])
        """
        cls = self.__class__ if isinstance(self, OrderedSet) else OrderedSet
        diff1 = cls(self).difference(other)
        diff2 = cls(other).difference(self)
        return diff1.union(diff2)

    def _update_items(self, items):
        """
        Replace the 'items' list of this OrderedSet with a new one, updating
        self.map accordingly.
        """
        self.items = items
        self.map = {item: idx for (idx, item) in enumerate(items)}

    def difference_update(self, *sets):
        """
        Update this OrderedSet to remove items from one or more other sets.

        Example:
            >>> this = OrderedSet([1, 2, 3])
            >>> this.difference_update(OrderedSet([2, 4]))
            >>> print(this)
            OrderedSet([1, 3])

            >>> this = OrderedSet([1, 2, 3, 4, 5])
            >>> this.difference_update(OrderedSet([2, 4]), OrderedSet([1, 4, 6]))
            >>> print(this)
            OrderedSet([3, 5])
        """
        items_to_remove = set()
        for other in sets:
            items_to_remove |= set(other)
        self._update_items([item for item in self.items if item not in items_to_remove])

    def intersection_update(self, other):
        """
        Update this OrderedSet to keep only items in another set, preserving
        their order in this set.

        Example:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.intersection_update(other)
            >>> print(this)
            OrderedSet([1, 3, 7])
        """
        other = set(other)
        self._update_items([item for item in self.items if item in other])

    def symmetric_difference_update(self, other):
        """
        Update this OrderedSet to remove items from another set, then
        add items from the other set that were not present in this set.

        Example:
            >>> this = OrderedSet([1, 4, 3, 5, 7])
            >>> other = OrderedSet([9, 7, 1, 3, 2])
            >>> this.symmetric_difference_update(other)
            >>> print(this)
            OrderedSet([4, 5, 9, 2])
        """
        items_to_add = [item for item in other if item not in self]
        items_to_remove = set(other)
        self._update_items(
            [item for item in self.items if item not in items_to_remove] + items_to_add
        )
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/packaging/0000755000175100001730000000000014467657444021260 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/__init__.py0000644000175100001730000000076514467657412023374 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

__title__ = "packaging"
__summary__ = "Core utilities for Python packages"
__uri__ = "https://github.com/pypa/packaging"

__version__ = "23.1"

__author__ = "Donald Stufft and individual contributors"
__email__ = "donald@stufft.io"

__license__ = "BSD-2-Clause or Apache-2.0"
__copyright__ = "2014-2019 %s" % __author__
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/_elffile.py0000644000175100001730000000630214467657412023373 0ustar00runnerdocker"""
ELF file parser.

This provides a class ``ELFFile`` that parses an ELF executable in a similar
interface to ``ZipFile``. Only the read interface is implemented.

Based on: https://gist.github.com/lyssdod/f51579ae8d93c8657a5564aefc2ffbca
ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
"""

import enum
import os
import struct
from typing import IO, Optional, Tuple


class ELFInvalid(ValueError):
    pass


class EIClass(enum.IntEnum):
    C32 = 1
    C64 = 2


class EIData(enum.IntEnum):
    Lsb = 1
    Msb = 2


class EMachine(enum.IntEnum):
    I386 = 3
    S390 = 22
    Arm = 40
    X8664 = 62
    AArc64 = 183


class ELFFile:
    """
    Representation of an ELF executable.
    """

    def __init__(self, f: IO[bytes]) -> None:
        self._f = f

        try:
            ident = self._read("16B")
        except struct.error:
            raise ELFInvalid("unable to parse identification")
        magic = bytes(ident[:4])
        if magic != b"\x7fELF":
            raise ELFInvalid(f"invalid magic: {magic!r}")

        self.capacity = ident[4]  # Format for program header (bitness).
        self.encoding = ident[5]  # Data structure encoding (endianness).

        try:
            # e_fmt: Format for program header.
            # p_fmt: Format for section header.
            # p_idx: Indexes to find p_type, p_offset, and p_filesz.
            e_fmt, self._p_fmt, self._p_idx = {
                (1, 1): ("HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)),  # 32-bit MSB.
                (2, 1): ("HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)),  # 64-bit MSB.
            }[(self.capacity, self.encoding)]
        except KeyError:
            raise ELFInvalid(
                f"unrecognized capacity ({self.capacity}) or "
                f"encoding ({self.encoding})"
            )

        try:
            (
                _,
                self.machine,  # Architecture type.
                _,
                _,
                self._e_phoff,  # Offset of program header.
                _,
                self.flags,  # Processor-specific flags.
                _,
                self._e_phentsize,  # Size of section.
                self._e_phnum,  # Number of sections.
            ) = self._read(e_fmt)
        except struct.error as e:
            raise ELFInvalid("unable to parse machine and section information") from e

    def _read(self, fmt: str) -> Tuple[int, ...]:
        return struct.unpack(fmt, self._f.read(struct.calcsize(fmt)))

    @property
    def interpreter(self) -> Optional[str]:
        """
        The path recorded in the ``PT_INTERP`` section header.
        """
        for index in range(self._e_phnum):
            self._f.seek(self._e_phoff + self._e_phentsize * index)
            try:
                data = self._read(self._p_fmt)
            except struct.error:
                continue
            if data[self._p_idx[0]] != 3:  # Not PT_INTERP.
                continue
            self._f.seek(data[self._p_idx[1]])
            return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0")
        return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/_manylinux.py0000644000175100001730000002133614467657412024015 0ustar00runnerdockerimport collections
import contextlib
import functools
import os
import re
import sys
import warnings
from typing import Dict, Generator, Iterator, NamedTuple, Optional, Tuple

from ._elffile import EIClass, EIData, ELFFile, EMachine

EF_ARM_ABIMASK = 0xFF000000
EF_ARM_ABI_VER5 = 0x05000000
EF_ARM_ABI_FLOAT_HARD = 0x00000400


# `os.PathLike` not a generic type until Python 3.9, so sticking with `str`
# as the type for `path` until then.
@contextlib.contextmanager
def _parse_elf(path: str) -> Generator[Optional[ELFFile], None, None]:
    try:
        with open(path, "rb") as f:
            yield ELFFile(f)
    except (OSError, TypeError, ValueError):
        yield None


def _is_linux_armhf(executable: str) -> bool:
    # hard-float ABI can be detected from the ELF header of the running
    # process
    # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf
    with _parse_elf(executable) as f:
        return (
            f is not None
            and f.capacity == EIClass.C32
            and f.encoding == EIData.Lsb
            and f.machine == EMachine.Arm
            and f.flags & EF_ARM_ABIMASK == EF_ARM_ABI_VER5
            and f.flags & EF_ARM_ABI_FLOAT_HARD == EF_ARM_ABI_FLOAT_HARD
        )


def _is_linux_i686(executable: str) -> bool:
    with _parse_elf(executable) as f:
        return (
            f is not None
            and f.capacity == EIClass.C32
            and f.encoding == EIData.Lsb
            and f.machine == EMachine.I386
        )


def _have_compatible_abi(executable: str, arch: str) -> bool:
    if arch == "armv7l":
        return _is_linux_armhf(executable)
    if arch == "i686":
        return _is_linux_i686(executable)
    return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"}


# If glibc ever changes its major version, we need to know what the last
# minor version was, so we can build the complete list of all versions.
# For now, guess what the highest minor version might be, assume it will
# be 50 for testing. Once this actually happens, update the dictionary
# with the actual value.
_LAST_GLIBC_MINOR: Dict[int, int] = collections.defaultdict(lambda: 50)


class _GLibCVersion(NamedTuple):
    major: int
    minor: int


def _glibc_version_string_confstr() -> Optional[str]:
    """
    Primary implementation of glibc_version_string using os.confstr.
    """
    # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
    # to be broken or missing. This strategy is used in the standard library
    # platform module.
    # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183
    try:
        # Should be a string like "glibc 2.17".
        version_string: str = getattr(os, "confstr")("CS_GNU_LIBC_VERSION")
        assert version_string is not None
        _, version = version_string.rsplit()
    except (AssertionError, AttributeError, OSError, ValueError):
        # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
        return None
    return version


def _glibc_version_string_ctypes() -> Optional[str]:
    """
    Fallback implementation of glibc_version_string using ctypes.
    """
    try:
        import ctypes
    except ImportError:
        return None

    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
    # manpage says, "If filename is NULL, then the returned handle is for the
    # main program". This way we can let the linker do the work to figure out
    # which libc our process is actually using.
    #
    # We must also handle the special case where the executable is not a
    # dynamically linked executable. This can occur when using musl libc,
    # for example. In this situation, dlopen() will error, leading to an
    # OSError. Interestingly, at least in the case of musl, there is no
    # errno set on the OSError. The single string argument used to construct
    # OSError comes from libc itself and is therefore not portable to
    # hard code here. In any case, failure to call dlopen() means we
    # can proceed, so we bail on our attempt.
    try:
        process_namespace = ctypes.CDLL(None)
    except OSError:
        return None

    try:
        gnu_get_libc_version = process_namespace.gnu_get_libc_version
    except AttributeError:
        # Symbol doesn't exist -> therefore, we are not linked to
        # glibc.
        return None

    # Call gnu_get_libc_version, which returns a string like "2.5"
    gnu_get_libc_version.restype = ctypes.c_char_p
    version_str: str = gnu_get_libc_version()
    # py2 / py3 compatibility:
    if not isinstance(version_str, str):
        version_str = version_str.decode("ascii")

    return version_str


def _glibc_version_string() -> Optional[str]:
    """Returns glibc version string, or None if not using glibc."""
    return _glibc_version_string_confstr() or _glibc_version_string_ctypes()


def _parse_glibc_version(version_str: str) -> Tuple[int, int]:
    """Parse glibc version.

    We use a regexp instead of str.split because we want to discard any
    random junk that might come after the minor version -- this might happen
    in patched/forked versions of glibc (e.g. Linaro's version of glibc
    uses version strings like "2.20-2014.11"). See gh-3588.
    """
    m = re.match(r"(?P[0-9]+)\.(?P[0-9]+)", version_str)
    if not m:
        warnings.warn(
            f"Expected glibc version with 2 components major.minor,"
            f" got: {version_str}",
            RuntimeWarning,
        )
        return -1, -1
    return int(m.group("major")), int(m.group("minor"))


@functools.lru_cache()
def _get_glibc_version() -> Tuple[int, int]:
    version_str = _glibc_version_string()
    if version_str is None:
        return (-1, -1)
    return _parse_glibc_version(version_str)


# From PEP 513, PEP 600
def _is_compatible(name: str, arch: str, version: _GLibCVersion) -> bool:
    sys_glibc = _get_glibc_version()
    if sys_glibc < version:
        return False
    # Check for presence of _manylinux module.
    try:
        import _manylinux  # noqa
    except ImportError:
        return True
    if hasattr(_manylinux, "manylinux_compatible"):
        result = _manylinux.manylinux_compatible(version[0], version[1], arch)
        if result is not None:
            return bool(result)
        return True
    if version == _GLibCVersion(2, 5):
        if hasattr(_manylinux, "manylinux1_compatible"):
            return bool(_manylinux.manylinux1_compatible)
    if version == _GLibCVersion(2, 12):
        if hasattr(_manylinux, "manylinux2010_compatible"):
            return bool(_manylinux.manylinux2010_compatible)
    if version == _GLibCVersion(2, 17):
        if hasattr(_manylinux, "manylinux2014_compatible"):
            return bool(_manylinux.manylinux2014_compatible)
    return True


_LEGACY_MANYLINUX_MAP = {
    # CentOS 7 w/ glibc 2.17 (PEP 599)
    (2, 17): "manylinux2014",
    # CentOS 6 w/ glibc 2.12 (PEP 571)
    (2, 12): "manylinux2010",
    # CentOS 5 w/ glibc 2.5 (PEP 513)
    (2, 5): "manylinux1",
}


def platform_tags(linux: str, arch: str) -> Iterator[str]:
    if not _have_compatible_abi(sys.executable, arch):
        return
    # Oldest glibc to be supported regardless of architecture is (2, 17).
    too_old_glibc2 = _GLibCVersion(2, 16)
    if arch in {"x86_64", "i686"}:
        # On x86/i686 also oldest glibc to be supported is (2, 5).
        too_old_glibc2 = _GLibCVersion(2, 4)
    current_glibc = _GLibCVersion(*_get_glibc_version())
    glibc_max_list = [current_glibc]
    # We can assume compatibility across glibc major versions.
    # https://sourceware.org/bugzilla/show_bug.cgi?id=24636
    #
    # Build a list of maximum glibc versions so that we can
    # output the canonical list of all glibc from current_glibc
    # down to too_old_glibc2, including all intermediary versions.
    for glibc_major in range(current_glibc.major - 1, 1, -1):
        glibc_minor = _LAST_GLIBC_MINOR[glibc_major]
        glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor))
    for glibc_max in glibc_max_list:
        if glibc_max.major == too_old_glibc2.major:
            min_minor = too_old_glibc2.minor
        else:
            # For other glibc major versions oldest supported is (x, 0).
            min_minor = -1
        for glibc_minor in range(glibc_max.minor, min_minor, -1):
            glibc_version = _GLibCVersion(glibc_max.major, glibc_minor)
            tag = "manylinux_{}_{}".format(*glibc_version)
            if _is_compatible(tag, arch, glibc_version):
                yield linux.replace("linux", tag)
            # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags.
            if glibc_version in _LEGACY_MANYLINUX_MAP:
                legacy_tag = _LEGACY_MANYLINUX_MAP[glibc_version]
                if _is_compatible(legacy_tag, arch, glibc_version):
                    yield linux.replace("linux", legacy_tag)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/_musllinux.py0000644000175100001730000000473414467657412024034 0ustar00runnerdocker"""PEP 656 support.

This module implements logic to detect if the currently running Python is
linked against musl, and what musl version is used.
"""

import functools
import re
import subprocess
import sys
from typing import Iterator, NamedTuple, Optional

from ._elffile import ELFFile


class _MuslVersion(NamedTuple):
    major: int
    minor: int


def _parse_musl_version(output: str) -> Optional[_MuslVersion]:
    lines = [n for n in (n.strip() for n in output.splitlines()) if n]
    if len(lines) < 2 or lines[0][:4] != "musl":
        return None
    m = re.match(r"Version (\d+)\.(\d+)", lines[1])
    if not m:
        return None
    return _MuslVersion(major=int(m.group(1)), minor=int(m.group(2)))


@functools.lru_cache()
def _get_musl_version(executable: str) -> Optional[_MuslVersion]:
    """Detect currently-running musl runtime version.

    This is done by checking the specified executable's dynamic linking
    information, and invoking the loader to parse its output for a version
    string. If the loader is musl, the output would be something like::

        musl libc (x86_64)
        Version 1.2.2
        Dynamic Program Loader
    """
    try:
        with open(executable, "rb") as f:
            ld = ELFFile(f).interpreter
    except (OSError, TypeError, ValueError):
        return None
    if ld is None or "musl" not in ld:
        return None
    proc = subprocess.run([ld], stderr=subprocess.PIPE, universal_newlines=True)
    return _parse_musl_version(proc.stderr)


def platform_tags(arch: str) -> Iterator[str]:
    """Generate musllinux tags compatible to the current platform.

    :param arch: Should be the part of platform tag after the ``linux_``
        prefix, e.g. ``x86_64``. The ``linux_`` prefix is assumed as a
        prerequisite for the current platform to be musllinux-compatible.

    :returns: An iterator of compatible musllinux tags.
    """
    sys_musl = _get_musl_version(sys.executable)
    if sys_musl is None:  # Python not dynamically linked against musl.
        return
    for minor in range(sys_musl.minor, -1, -1):
        yield f"musllinux_{sys_musl.major}_{minor}_{arch}"


if __name__ == "__main__":  # pragma: no cover
    import sysconfig

    plat = sysconfig.get_platform()
    assert plat.startswith("linux-"), "not linux"

    print("plat:", plat)
    print("musl:", _get_musl_version(sys.executable))
    print("tags:", end=" ")
    for t in platform_tags(re.sub(r"[.-]", "_", plat.split("-", 1)[-1])):
        print(t, end="\n      ")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/_parser.py0000644000175100001730000002372214467657412023266 0ustar00runnerdocker"""Handwritten parser of dependency specifiers.

The docstring for each __parse_* function contains ENBF-inspired grammar representing
the implementation.
"""

import ast
from typing import Any, List, NamedTuple, Optional, Tuple, Union

from ._tokenizer import DEFAULT_RULES, Tokenizer


class Node:
    def __init__(self, value: str) -> None:
        self.value = value

    def __str__(self) -> str:
        return self.value

    def __repr__(self) -> str:
        return f"<{self.__class__.__name__}('{self}')>"

    def serialize(self) -> str:
        raise NotImplementedError


class Variable(Node):
    def serialize(self) -> str:
        return str(self)


class Value(Node):
    def serialize(self) -> str:
        return f'"{self}"'


class Op(Node):
    def serialize(self) -> str:
        return str(self)


MarkerVar = Union[Variable, Value]
MarkerItem = Tuple[MarkerVar, Op, MarkerVar]
# MarkerAtom = Union[MarkerItem, List["MarkerAtom"]]
# MarkerList = List[Union["MarkerList", MarkerAtom, str]]
# mypy does not support recursive type definition
# https://github.com/python/mypy/issues/731
MarkerAtom = Any
MarkerList = List[Any]


class ParsedRequirement(NamedTuple):
    name: str
    url: str
    extras: List[str]
    specifier: str
    marker: Optional[MarkerList]


# --------------------------------------------------------------------------------------
# Recursive descent parser for dependency specifier
# --------------------------------------------------------------------------------------
def parse_requirement(source: str) -> ParsedRequirement:
    return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES))


def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement:
    """
    requirement = WS? IDENTIFIER WS? extras WS? requirement_details
    """
    tokenizer.consume("WS")

    name_token = tokenizer.expect(
        "IDENTIFIER", expected="package name at the start of dependency specifier"
    )
    name = name_token.text
    tokenizer.consume("WS")

    extras = _parse_extras(tokenizer)
    tokenizer.consume("WS")

    url, specifier, marker = _parse_requirement_details(tokenizer)
    tokenizer.expect("END", expected="end of dependency specifier")

    return ParsedRequirement(name, url, extras, specifier, marker)


def _parse_requirement_details(
    tokenizer: Tokenizer,
) -> Tuple[str, str, Optional[MarkerList]]:
    """
    requirement_details = AT URL (WS requirement_marker?)?
                        | specifier WS? (requirement_marker)?
    """

    specifier = ""
    url = ""
    marker = None

    if tokenizer.check("AT"):
        tokenizer.read()
        tokenizer.consume("WS")

        url_start = tokenizer.position
        url = tokenizer.expect("URL", expected="URL after @").text
        if tokenizer.check("END", peek=True):
            return (url, specifier, marker)

        tokenizer.expect("WS", expected="whitespace after URL")

        # The input might end after whitespace.
        if tokenizer.check("END", peek=True):
            return (url, specifier, marker)

        marker = _parse_requirement_marker(
            tokenizer, span_start=url_start, after="URL and whitespace"
        )
    else:
        specifier_start = tokenizer.position
        specifier = _parse_specifier(tokenizer)
        tokenizer.consume("WS")

        if tokenizer.check("END", peek=True):
            return (url, specifier, marker)

        marker = _parse_requirement_marker(
            tokenizer,
            span_start=specifier_start,
            after=(
                "version specifier"
                if specifier
                else "name and no valid version specifier"
            ),
        )

    return (url, specifier, marker)


def _parse_requirement_marker(
    tokenizer: Tokenizer, *, span_start: int, after: str
) -> MarkerList:
    """
    requirement_marker = SEMICOLON marker WS?
    """

    if not tokenizer.check("SEMICOLON"):
        tokenizer.raise_syntax_error(
            f"Expected end or semicolon (after {after})",
            span_start=span_start,
        )
    tokenizer.read()

    marker = _parse_marker(tokenizer)
    tokenizer.consume("WS")

    return marker


def _parse_extras(tokenizer: Tokenizer) -> List[str]:
    """
    extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)?
    """
    if not tokenizer.check("LEFT_BRACKET", peek=True):
        return []

    with tokenizer.enclosing_tokens(
        "LEFT_BRACKET",
        "RIGHT_BRACKET",
        around="extras",
    ):
        tokenizer.consume("WS")
        extras = _parse_extras_list(tokenizer)
        tokenizer.consume("WS")

    return extras


def _parse_extras_list(tokenizer: Tokenizer) -> List[str]:
    """
    extras_list = identifier (wsp* ',' wsp* identifier)*
    """
    extras: List[str] = []

    if not tokenizer.check("IDENTIFIER"):
        return extras

    extras.append(tokenizer.read().text)

    while True:
        tokenizer.consume("WS")
        if tokenizer.check("IDENTIFIER", peek=True):
            tokenizer.raise_syntax_error("Expected comma between extra names")
        elif not tokenizer.check("COMMA"):
            break

        tokenizer.read()
        tokenizer.consume("WS")

        extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma")
        extras.append(extra_token.text)

    return extras


def _parse_specifier(tokenizer: Tokenizer) -> str:
    """
    specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS
              | WS? version_many WS?
    """
    with tokenizer.enclosing_tokens(
        "LEFT_PARENTHESIS",
        "RIGHT_PARENTHESIS",
        around="version specifier",
    ):
        tokenizer.consume("WS")
        parsed_specifiers = _parse_version_many(tokenizer)
        tokenizer.consume("WS")

    return parsed_specifiers


def _parse_version_many(tokenizer: Tokenizer) -> str:
    """
    version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)?
    """
    parsed_specifiers = ""
    while tokenizer.check("SPECIFIER"):
        span_start = tokenizer.position
        parsed_specifiers += tokenizer.read().text
        if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True):
            tokenizer.raise_syntax_error(
                ".* suffix can only be used with `==` or `!=` operators",
                span_start=span_start,
                span_end=tokenizer.position + 1,
            )
        if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True):
            tokenizer.raise_syntax_error(
                "Local version label can only be used with `==` or `!=` operators",
                span_start=span_start,
                span_end=tokenizer.position,
            )
        tokenizer.consume("WS")
        if not tokenizer.check("COMMA"):
            break
        parsed_specifiers += tokenizer.read().text
        tokenizer.consume("WS")

    return parsed_specifiers


# --------------------------------------------------------------------------------------
# Recursive descent parser for marker expression
# --------------------------------------------------------------------------------------
def parse_marker(source: str) -> MarkerList:
    return _parse_marker(Tokenizer(source, rules=DEFAULT_RULES))


def _parse_marker(tokenizer: Tokenizer) -> MarkerList:
    """
    marker = marker_atom (BOOLOP marker_atom)+
    """
    expression = [_parse_marker_atom(tokenizer)]
    while tokenizer.check("BOOLOP"):
        token = tokenizer.read()
        expr_right = _parse_marker_atom(tokenizer)
        expression.extend((token.text, expr_right))
    return expression


def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom:
    """
    marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS?
                | WS? marker_item WS?
    """

    tokenizer.consume("WS")
    if tokenizer.check("LEFT_PARENTHESIS", peek=True):
        with tokenizer.enclosing_tokens(
            "LEFT_PARENTHESIS",
            "RIGHT_PARENTHESIS",
            around="marker expression",
        ):
            tokenizer.consume("WS")
            marker: MarkerAtom = _parse_marker(tokenizer)
            tokenizer.consume("WS")
    else:
        marker = _parse_marker_item(tokenizer)
    tokenizer.consume("WS")
    return marker


def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem:
    """
    marker_item = WS? marker_var WS? marker_op WS? marker_var WS?
    """
    tokenizer.consume("WS")
    marker_var_left = _parse_marker_var(tokenizer)
    tokenizer.consume("WS")
    marker_op = _parse_marker_op(tokenizer)
    tokenizer.consume("WS")
    marker_var_right = _parse_marker_var(tokenizer)
    tokenizer.consume("WS")
    return (marker_var_left, marker_op, marker_var_right)


def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar:
    """
    marker_var = VARIABLE | QUOTED_STRING
    """
    if tokenizer.check("VARIABLE"):
        return process_env_var(tokenizer.read().text.replace(".", "_"))
    elif tokenizer.check("QUOTED_STRING"):
        return process_python_str(tokenizer.read().text)
    else:
        tokenizer.raise_syntax_error(
            message="Expected a marker variable or quoted string"
        )


def process_env_var(env_var: str) -> Variable:
    if (
        env_var == "platform_python_implementation"
        or env_var == "python_implementation"
    ):
        return Variable("platform_python_implementation")
    else:
        return Variable(env_var)


def process_python_str(python_str: str) -> Value:
    value = ast.literal_eval(python_str)
    return Value(str(value))


def _parse_marker_op(tokenizer: Tokenizer) -> Op:
    """
    marker_op = IN | NOT IN | OP
    """
    if tokenizer.check("IN"):
        tokenizer.read()
        return Op("in")
    elif tokenizer.check("NOT"):
        tokenizer.read()
        tokenizer.expect("WS", expected="whitespace after 'not'")
        tokenizer.expect("IN", expected="'in' after 'not'")
        return Op("not in")
    elif tokenizer.check("OP"):
        return Op(tokenizer.read().text)
    else:
        return tokenizer.raise_syntax_error(
            "Expected marker operator, one of "
            "<=, <, !=, ==, >=, >, ~=, ===, in, not in"
        )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/_structures.py0000644000175100001730000000262714467657412024216 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.


class InfinityType:
    def __repr__(self) -> str:
        return "Infinity"

    def __hash__(self) -> int:
        return hash(repr(self))

    def __lt__(self, other: object) -> bool:
        return False

    def __le__(self, other: object) -> bool:
        return False

    def __eq__(self, other: object) -> bool:
        return isinstance(other, self.__class__)

    def __gt__(self, other: object) -> bool:
        return True

    def __ge__(self, other: object) -> bool:
        return True

    def __neg__(self: object) -> "NegativeInfinityType":
        return NegativeInfinity


Infinity = InfinityType()


class NegativeInfinityType:
    def __repr__(self) -> str:
        return "-Infinity"

    def __hash__(self) -> int:
        return hash(repr(self))

    def __lt__(self, other: object) -> bool:
        return True

    def __le__(self, other: object) -> bool:
        return True

    def __eq__(self, other: object) -> bool:
        return isinstance(other, self.__class__)

    def __gt__(self, other: object) -> bool:
        return False

    def __ge__(self, other: object) -> bool:
        return False

    def __neg__(self: object) -> InfinityType:
        return Infinity


NegativeInfinity = NegativeInfinityType()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/_tokenizer.py0000644000175100001730000001225414467657412024002 0ustar00runnerdockerimport contextlib
import re
from dataclasses import dataclass
from typing import Dict, Iterator, NoReturn, Optional, Tuple, Union

from .specifiers import Specifier


@dataclass
class Token:
    name: str
    text: str
    position: int


class ParserSyntaxError(Exception):
    """The provided source text could not be parsed correctly."""

    def __init__(
        self,
        message: str,
        *,
        source: str,
        span: Tuple[int, int],
    ) -> None:
        self.span = span
        self.message = message
        self.source = source

        super().__init__()

    def __str__(self) -> str:
        marker = " " * self.span[0] + "~" * (self.span[1] - self.span[0]) + "^"
        return "\n    ".join([self.message, self.source, marker])


DEFAULT_RULES: "Dict[str, Union[str, re.Pattern[str]]]" = {
    "LEFT_PARENTHESIS": r"\(",
    "RIGHT_PARENTHESIS": r"\)",
    "LEFT_BRACKET": r"\[",
    "RIGHT_BRACKET": r"\]",
    "SEMICOLON": r";",
    "COMMA": r",",
    "QUOTED_STRING": re.compile(
        r"""
            (
                ('[^']*')
                |
                ("[^"]*")
            )
        """,
        re.VERBOSE,
    ),
    "OP": r"(===|==|~=|!=|<=|>=|<|>)",
    "BOOLOP": r"\b(or|and)\b",
    "IN": r"\bin\b",
    "NOT": r"\bnot\b",
    "VARIABLE": re.compile(
        r"""
            \b(
                python_version
                |python_full_version
                |os[._]name
                |sys[._]platform
                |platform_(release|system)
                |platform[._](version|machine|python_implementation)
                |python_implementation
                |implementation_(name|version)
                |extra
            )\b
        """,
        re.VERBOSE,
    ),
    "SPECIFIER": re.compile(
        Specifier._operator_regex_str + Specifier._version_regex_str,
        re.VERBOSE | re.IGNORECASE,
    ),
    "AT": r"\@",
    "URL": r"[^ \t]+",
    "IDENTIFIER": r"\b[a-zA-Z0-9][a-zA-Z0-9._-]*\b",
    "VERSION_PREFIX_TRAIL": r"\.\*",
    "VERSION_LOCAL_LABEL_TRAIL": r"\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*",
    "WS": r"[ \t]+",
    "END": r"$",
}


class Tokenizer:
    """Context-sensitive token parsing.

    Provides methods to examine the input stream to check whether the next token
    matches.
    """

    def __init__(
        self,
        source: str,
        *,
        rules: "Dict[str, Union[str, re.Pattern[str]]]",
    ) -> None:
        self.source = source
        self.rules: Dict[str, re.Pattern[str]] = {
            name: re.compile(pattern) for name, pattern in rules.items()
        }
        self.next_token: Optional[Token] = None
        self.position = 0

    def consume(self, name: str) -> None:
        """Move beyond provided token name, if at current position."""
        if self.check(name):
            self.read()

    def check(self, name: str, *, peek: bool = False) -> bool:
        """Check whether the next token has the provided name.

        By default, if the check succeeds, the token *must* be read before
        another check. If `peek` is set to `True`, the token is not loaded and
        would need to be checked again.
        """
        assert (
            self.next_token is None
        ), f"Cannot check for {name!r}, already have {self.next_token!r}"
        assert name in self.rules, f"Unknown token name: {name!r}"

        expression = self.rules[name]

        match = expression.match(self.source, self.position)
        if match is None:
            return False
        if not peek:
            self.next_token = Token(name, match[0], self.position)
        return True

    def expect(self, name: str, *, expected: str) -> Token:
        """Expect a certain token name next, failing with a syntax error otherwise.

        The token is *not* read.
        """
        if not self.check(name):
            raise self.raise_syntax_error(f"Expected {expected}")
        return self.read()

    def read(self) -> Token:
        """Consume the next token and return it."""
        token = self.next_token
        assert token is not None

        self.position += len(token.text)
        self.next_token = None

        return token

    def raise_syntax_error(
        self,
        message: str,
        *,
        span_start: Optional[int] = None,
        span_end: Optional[int] = None,
    ) -> NoReturn:
        """Raise ParserSyntaxError at the given position."""
        span = (
            self.position if span_start is None else span_start,
            self.position if span_end is None else span_end,
        )
        raise ParserSyntaxError(
            message,
            source=self.source,
            span=span,
        )

    @contextlib.contextmanager
    def enclosing_tokens(
        self, open_token: str, close_token: str, *, around: str
    ) -> Iterator[None]:
        if self.check(open_token):
            open_position = self.position
            self.read()
        else:
            open_position = None

        yield

        if open_position is None:
            return

        if not self.check(close_token):
            self.raise_syntax_error(
                f"Expected matching {close_token} for {open_token}, after {around}",
                span_start=open_position,
            )

        self.read()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/markers.py0000644000175100001730000002002014467657412023263 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import operator
import os
import platform
import sys
from typing import Any, Callable, Dict, List, Optional, Tuple, Union

from ._parser import (
    MarkerAtom,
    MarkerList,
    Op,
    Value,
    Variable,
    parse_marker as _parse_marker,
)
from ._tokenizer import ParserSyntaxError
from .specifiers import InvalidSpecifier, Specifier
from .utils import canonicalize_name

__all__ = [
    "InvalidMarker",
    "UndefinedComparison",
    "UndefinedEnvironmentName",
    "Marker",
    "default_environment",
]

Operator = Callable[[str, str], bool]


class InvalidMarker(ValueError):
    """
    An invalid marker was found, users should refer to PEP 508.
    """


class UndefinedComparison(ValueError):
    """
    An invalid operation was attempted on a value that doesn't support it.
    """


class UndefinedEnvironmentName(ValueError):
    """
    A name was attempted to be used that does not exist inside of the
    environment.
    """


def _normalize_extra_values(results: Any) -> Any:
    """
    Normalize extra values.
    """
    if isinstance(results[0], tuple):
        lhs, op, rhs = results[0]
        if isinstance(lhs, Variable) and lhs.value == "extra":
            normalized_extra = canonicalize_name(rhs.value)
            rhs = Value(normalized_extra)
        elif isinstance(rhs, Variable) and rhs.value == "extra":
            normalized_extra = canonicalize_name(lhs.value)
            lhs = Value(normalized_extra)
        results[0] = lhs, op, rhs
    return results


def _format_marker(
    marker: Union[List[str], MarkerAtom, str], first: Optional[bool] = True
) -> str:

    assert isinstance(marker, (list, tuple, str))

    # Sometimes we have a structure like [[...]] which is a single item list
    # where the single item is itself it's own list. In that case we want skip
    # the rest of this function so that we don't get extraneous () on the
    # outside.
    if (
        isinstance(marker, list)
        and len(marker) == 1
        and isinstance(marker[0], (list, tuple))
    ):
        return _format_marker(marker[0])

    if isinstance(marker, list):
        inner = (_format_marker(m, first=False) for m in marker)
        if first:
            return " ".join(inner)
        else:
            return "(" + " ".join(inner) + ")"
    elif isinstance(marker, tuple):
        return " ".join([m.serialize() for m in marker])
    else:
        return marker


_operators: Dict[str, Operator] = {
    "in": lambda lhs, rhs: lhs in rhs,
    "not in": lambda lhs, rhs: lhs not in rhs,
    "<": operator.lt,
    "<=": operator.le,
    "==": operator.eq,
    "!=": operator.ne,
    ">=": operator.ge,
    ">": operator.gt,
}


def _eval_op(lhs: str, op: Op, rhs: str) -> bool:
    try:
        spec = Specifier("".join([op.serialize(), rhs]))
    except InvalidSpecifier:
        pass
    else:
        return spec.contains(lhs, prereleases=True)

    oper: Optional[Operator] = _operators.get(op.serialize())
    if oper is None:
        raise UndefinedComparison(f"Undefined {op!r} on {lhs!r} and {rhs!r}.")

    return oper(lhs, rhs)


def _normalize(*values: str, key: str) -> Tuple[str, ...]:
    # PEP 685 – Comparison of extra names for optional distribution dependencies
    # https://peps.python.org/pep-0685/
    # > When comparing extra names, tools MUST normalize the names being
    # > compared using the semantics outlined in PEP 503 for names
    if key == "extra":
        return tuple(canonicalize_name(v) for v in values)

    # other environment markers don't have such standards
    return values


def _evaluate_markers(markers: MarkerList, environment: Dict[str, str]) -> bool:
    groups: List[List[bool]] = [[]]

    for marker in markers:
        assert isinstance(marker, (list, tuple, str))

        if isinstance(marker, list):
            groups[-1].append(_evaluate_markers(marker, environment))
        elif isinstance(marker, tuple):
            lhs, op, rhs = marker

            if isinstance(lhs, Variable):
                environment_key = lhs.value
                lhs_value = environment[environment_key]
                rhs_value = rhs.value
            else:
                lhs_value = lhs.value
                environment_key = rhs.value
                rhs_value = environment[environment_key]

            lhs_value, rhs_value = _normalize(lhs_value, rhs_value, key=environment_key)
            groups[-1].append(_eval_op(lhs_value, op, rhs_value))
        else:
            assert marker in ["and", "or"]
            if marker == "or":
                groups.append([])

    return any(all(item) for item in groups)


def format_full_version(info: "sys._version_info") -> str:
    version = "{0.major}.{0.minor}.{0.micro}".format(info)
    kind = info.releaselevel
    if kind != "final":
        version += kind[0] + str(info.serial)
    return version


def default_environment() -> Dict[str, str]:
    iver = format_full_version(sys.implementation.version)
    implementation_name = sys.implementation.name
    return {
        "implementation_name": implementation_name,
        "implementation_version": iver,
        "os_name": os.name,
        "platform_machine": platform.machine(),
        "platform_release": platform.release(),
        "platform_system": platform.system(),
        "platform_version": platform.version(),
        "python_full_version": platform.python_version(),
        "platform_python_implementation": platform.python_implementation(),
        "python_version": ".".join(platform.python_version_tuple()[:2]),
        "sys_platform": sys.platform,
    }


class Marker:
    def __init__(self, marker: str) -> None:
        # Note: We create a Marker object without calling this constructor in
        #       packaging.requirements.Requirement. If any additional logic is
        #       added here, make sure to mirror/adapt Requirement.
        try:
            self._markers = _normalize_extra_values(_parse_marker(marker))
            # The attribute `_markers` can be described in terms of a recursive type:
            # MarkerList = List[Union[Tuple[Node, ...], str, MarkerList]]
            #
            # For example, the following expression:
            # python_version > "3.6" or (python_version == "3.6" and os_name == "unix")
            #
            # is parsed into:
            # [
            #     (, ')>, ),
            #     'and',
            #     [
            #         (, , ),
            #         'or',
            #         (, , )
            #     ]
            # ]
        except ParserSyntaxError as e:
            raise InvalidMarker(str(e)) from e

    def __str__(self) -> str:
        return _format_marker(self._markers)

    def __repr__(self) -> str:
        return f""

    def __hash__(self) -> int:
        return hash((self.__class__.__name__, str(self)))

    def __eq__(self, other: Any) -> bool:
        if not isinstance(other, Marker):
            return NotImplemented

        return str(self) == str(other)

    def evaluate(self, environment: Optional[Dict[str, str]] = None) -> bool:
        """Evaluate a marker.

        Return the boolean from evaluating the given marker against the
        environment. environment is an optional argument to override all or
        part of the determined environment.

        The environment is determined from the current Python process.
        """
        current_environment = default_environment()
        current_environment["extra"] = ""
        if environment is not None:
            current_environment.update(environment)
            # The API used to allow setting extra to None. We need to handle this
            # case for backwards compatibility.
            if current_environment["extra"] is None:
                current_environment["extra"] = ""

        return _evaluate_markers(self._markers, current_environment)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/metadata.py0000644000175100001730000004001514467657412023405 0ustar00runnerdockerimport email.feedparser
import email.header
import email.message
import email.parser
import email.policy
import sys
import typing
from typing import Dict, List, Optional, Tuple, Union, cast

if sys.version_info >= (3, 8):  # pragma: no cover
    from typing import TypedDict
else:  # pragma: no cover
    if typing.TYPE_CHECKING:
        from typing_extensions import TypedDict
    else:
        try:
            from typing_extensions import TypedDict
        except ImportError:

            class TypedDict:
                def __init_subclass__(*_args, **_kwargs):
                    pass


# The RawMetadata class attempts to make as few assumptions about the underlying
# serialization formats as possible. The idea is that as long as a serialization
# formats offer some very basic primitives in *some* way then we can support
# serializing to and from that format.
class RawMetadata(TypedDict, total=False):
    """A dictionary of raw core metadata.

    Each field in core metadata maps to a key of this dictionary (when data is
    provided). The key is lower-case and underscores are used instead of dashes
    compared to the equivalent core metadata field. Any core metadata field that
    can be specified multiple times or can hold multiple values in a single
    field have a key with a plural name.

    Core metadata fields that can be specified multiple times are stored as a
    list or dict depending on which is appropriate for the field. Any fields
    which hold multiple values in a single field are stored as a list.

    """

    # Metadata 1.0 - PEP 241
    metadata_version: str
    name: str
    version: str
    platforms: List[str]
    summary: str
    description: str
    keywords: List[str]
    home_page: str
    author: str
    author_email: str
    license: str

    # Metadata 1.1 - PEP 314
    supported_platforms: List[str]
    download_url: str
    classifiers: List[str]
    requires: List[str]
    provides: List[str]
    obsoletes: List[str]

    # Metadata 1.2 - PEP 345
    maintainer: str
    maintainer_email: str
    requires_dist: List[str]
    provides_dist: List[str]
    obsoletes_dist: List[str]
    requires_python: str
    requires_external: List[str]
    project_urls: Dict[str, str]

    # Metadata 2.0
    # PEP 426 attempted to completely revamp the metadata format
    # but got stuck without ever being able to build consensus on
    # it and ultimately ended up withdrawn.
    #
    # However, a number of tools had started emiting METADATA with
    # `2.0` Metadata-Version, so for historical reasons, this version
    # was skipped.

    # Metadata 2.1 - PEP 566
    description_content_type: str
    provides_extra: List[str]

    # Metadata 2.2 - PEP 643
    dynamic: List[str]

    # Metadata 2.3 - PEP 685
    # No new fields were added in PEP 685, just some edge case were
    # tightened up to provide better interoptability.


_STRING_FIELDS = {
    "author",
    "author_email",
    "description",
    "description_content_type",
    "download_url",
    "home_page",
    "license",
    "maintainer",
    "maintainer_email",
    "metadata_version",
    "name",
    "requires_python",
    "summary",
    "version",
}

_LIST_STRING_FIELDS = {
    "classifiers",
    "dynamic",
    "obsoletes",
    "obsoletes_dist",
    "platforms",
    "provides",
    "provides_dist",
    "provides_extra",
    "requires",
    "requires_dist",
    "requires_external",
    "supported_platforms",
}


def _parse_keywords(data: str) -> List[str]:
    """Split a string of comma-separate keyboards into a list of keywords."""
    return [k.strip() for k in data.split(",")]


def _parse_project_urls(data: List[str]) -> Dict[str, str]:
    """Parse a list of label/URL string pairings separated by a comma."""
    urls = {}
    for pair in data:
        # Our logic is slightly tricky here as we want to try and do
        # *something* reasonable with malformed data.
        #
        # The main thing that we have to worry about, is data that does
        # not have a ',' at all to split the label from the Value. There
        # isn't a singular right answer here, and we will fail validation
        # later on (if the caller is validating) so it doesn't *really*
        # matter, but since the missing value has to be an empty str
        # and our return value is dict[str, str], if we let the key
        # be the missing value, then they'd have multiple '' values that
        # overwrite each other in a accumulating dict.
        #
        # The other potentional issue is that it's possible to have the
        # same label multiple times in the metadata, with no solid "right"
        # answer with what to do in that case. As such, we'll do the only
        # thing we can, which is treat the field as unparseable and add it
        # to our list of unparsed fields.
        parts = [p.strip() for p in pair.split(",", 1)]
        parts.extend([""] * (max(0, 2 - len(parts))))  # Ensure 2 items

        # TODO: The spec doesn't say anything about if the keys should be
        #       considered case sensitive or not... logically they should
        #       be case-preserving and case-insensitive, but doing that
        #       would open up more cases where we might have duplicate
        #       entries.
        label, url = parts
        if label in urls:
            # The label already exists in our set of urls, so this field
            # is unparseable, and we can just add the whole thing to our
            # unparseable data and stop processing it.
            raise KeyError("duplicate labels in project urls")
        urls[label] = url

    return urls


def _get_payload(msg: email.message.Message, source: Union[bytes, str]) -> str:
    """Get the body of the message."""
    # If our source is a str, then our caller has managed encodings for us,
    # and we don't need to deal with it.
    if isinstance(source, str):
        payload: str = msg.get_payload()
        return payload
    # If our source is a bytes, then we're managing the encoding and we need
    # to deal with it.
    else:
        bpayload: bytes = msg.get_payload(decode=True)
        try:
            return bpayload.decode("utf8", "strict")
        except UnicodeDecodeError:
            raise ValueError("payload in an invalid encoding")


# The various parse_FORMAT functions here are intended to be as lenient as
# possible in their parsing, while still returning a correctly typed
# RawMetadata.
#
# To aid in this, we also generally want to do as little touching of the
# data as possible, except where there are possibly some historic holdovers
# that make valid data awkward to work with.
#
# While this is a lower level, intermediate format than our ``Metadata``
# class, some light touch ups can make a massive difference in usability.

# Map METADATA fields to RawMetadata.
_EMAIL_TO_RAW_MAPPING = {
    "author": "author",
    "author-email": "author_email",
    "classifier": "classifiers",
    "description": "description",
    "description-content-type": "description_content_type",
    "download-url": "download_url",
    "dynamic": "dynamic",
    "home-page": "home_page",
    "keywords": "keywords",
    "license": "license",
    "maintainer": "maintainer",
    "maintainer-email": "maintainer_email",
    "metadata-version": "metadata_version",
    "name": "name",
    "obsoletes": "obsoletes",
    "obsoletes-dist": "obsoletes_dist",
    "platform": "platforms",
    "project-url": "project_urls",
    "provides": "provides",
    "provides-dist": "provides_dist",
    "provides-extra": "provides_extra",
    "requires": "requires",
    "requires-dist": "requires_dist",
    "requires-external": "requires_external",
    "requires-python": "requires_python",
    "summary": "summary",
    "supported-platform": "supported_platforms",
    "version": "version",
}


def parse_email(data: Union[bytes, str]) -> Tuple[RawMetadata, Dict[str, List[str]]]:
    """Parse a distribution's metadata.

    This function returns a two-item tuple of dicts. The first dict is of
    recognized fields from the core metadata specification. Fields that can be
    parsed and translated into Python's built-in types are converted
    appropriately. All other fields are left as-is. Fields that are allowed to
    appear multiple times are stored as lists.

    The second dict contains all other fields from the metadata. This includes
    any unrecognized fields. It also includes any fields which are expected to
    be parsed into a built-in type but were not formatted appropriately. Finally,
    any fields that are expected to appear only once but are repeated are
    included in this dict.

    """
    raw: Dict[str, Union[str, List[str], Dict[str, str]]] = {}
    unparsed: Dict[str, List[str]] = {}

    if isinstance(data, str):
        parsed = email.parser.Parser(policy=email.policy.compat32).parsestr(data)
    else:
        parsed = email.parser.BytesParser(policy=email.policy.compat32).parsebytes(data)

    # We have to wrap parsed.keys() in a set, because in the case of multiple
    # values for a key (a list), the key will appear multiple times in the
    # list of keys, but we're avoiding that by using get_all().
    for name in frozenset(parsed.keys()):
        # Header names in RFC are case insensitive, so we'll normalize to all
        # lower case to make comparisons easier.
        name = name.lower()

        # We use get_all() here, even for fields that aren't multiple use,
        # because otherwise someone could have e.g. two Name fields, and we
        # would just silently ignore it rather than doing something about it.
        headers = parsed.get_all(name)

        # The way the email module works when parsing bytes is that it
        # unconditionally decodes the bytes as ascii using the surrogateescape
        # handler. When you pull that data back out (such as with get_all() ),
        # it looks to see if the str has any surrogate escapes, and if it does
        # it wraps it in a Header object instead of returning the string.
        #
        # As such, we'll look for those Header objects, and fix up the encoding.
        value = []
        # Flag if we have run into any issues processing the headers, thus
        # signalling that the data belongs in 'unparsed'.
        valid_encoding = True
        for h in headers:
            # It's unclear if this can return more types than just a Header or
            # a str, so we'll just assert here to make sure.
            assert isinstance(h, (email.header.Header, str))

            # If it's a header object, we need to do our little dance to get
            # the real data out of it. In cases where there is invalid data
            # we're going to end up with mojibake, but there's no obvious, good
            # way around that without reimplementing parts of the Header object
            # ourselves.
            #
            # That should be fine since, if mojibacked happens, this key is
            # going into the unparsed dict anyways.
            if isinstance(h, email.header.Header):
                # The Header object stores it's data as chunks, and each chunk
                # can be independently encoded, so we'll need to check each
                # of them.
                chunks: List[Tuple[bytes, Optional[str]]] = []
                for bin, encoding in email.header.decode_header(h):
                    try:
                        bin.decode("utf8", "strict")
                    except UnicodeDecodeError:
                        # Enable mojibake.
                        encoding = "latin1"
                        valid_encoding = False
                    else:
                        encoding = "utf8"
                    chunks.append((bin, encoding))

                # Turn our chunks back into a Header object, then let that
                # Header object do the right thing to turn them into a
                # string for us.
                value.append(str(email.header.make_header(chunks)))
            # This is already a string, so just add it.
            else:
                value.append(h)

        # We've processed all of our values to get them into a list of str,
        # but we may have mojibake data, in which case this is an unparsed
        # field.
        if not valid_encoding:
            unparsed[name] = value
            continue

        raw_name = _EMAIL_TO_RAW_MAPPING.get(name)
        if raw_name is None:
            # This is a bit of a weird situation, we've encountered a key that
            # we don't know what it means, so we don't know whether it's meant
            # to be a list or not.
            #
            # Since we can't really tell one way or another, we'll just leave it
            # as a list, even though it may be a single item list, because that's
            # what makes the most sense for email headers.
            unparsed[name] = value
            continue

        # If this is one of our string fields, then we'll check to see if our
        # value is a list of a single item. If it is then we'll assume that
        # it was emitted as a single string, and unwrap the str from inside
        # the list.
        #
        # If it's any other kind of data, then we haven't the faintest clue
        # what we should parse it as, and we have to just add it to our list
        # of unparsed stuff.
        if raw_name in _STRING_FIELDS and len(value) == 1:
            raw[raw_name] = value[0]
        # If this is one of our list of string fields, then we can just assign
        # the value, since email *only* has strings, and our get_all() call
        # above ensures that this is a list.
        elif raw_name in _LIST_STRING_FIELDS:
            raw[raw_name] = value
        # Special Case: Keywords
        # The keywords field is implemented in the metadata spec as a str,
        # but it conceptually is a list of strings, and is serialized using
        # ", ".join(keywords), so we'll do some light data massaging to turn
        # this into what it logically is.
        elif raw_name == "keywords" and len(value) == 1:
            raw[raw_name] = _parse_keywords(value[0])
        # Special Case: Project-URL
        # The project urls is implemented in the metadata spec as a list of
        # specially-formatted strings that represent a key and a value, which
        # is fundamentally a mapping, however the email format doesn't support
        # mappings in a sane way, so it was crammed into a list of strings
        # instead.
        #
        # We will do a little light data massaging to turn this into a map as
        # it logically should be.
        elif raw_name == "project_urls":
            try:
                raw[raw_name] = _parse_project_urls(value)
            except KeyError:
                unparsed[name] = value
        # Nothing that we've done has managed to parse this, so it'll just
        # throw it in our unparseable data and move on.
        else:
            unparsed[name] = value

    # We need to support getting the Description from the message payload in
    # addition to getting it from the the headers. This does mean, though, there
    # is the possibility of it being set both ways, in which case we put both
    # in 'unparsed' since we don't know which is right.
    try:
        payload = _get_payload(parsed, data)
    except ValueError:
        unparsed.setdefault("description", []).append(
            parsed.get_payload(decode=isinstance(data, bytes))
        )
    else:
        if payload:
            # Check to see if we've already got a description, if so then both
            # it, and this body move to unparseable.
            if "description" in raw:
                description_header = cast(str, raw.pop("description"))
                unparsed.setdefault("description", []).extend(
                    [description_header, payload]
                )
            elif "description" in unparsed:
                unparsed["description"].append(payload)
            else:
                raw["description"] = payload

    # We need to cast our `raw` to a metadata, because a TypedDict only support
    # literal key names, but we're computing our key names on purpose, but the
    # way this function is implemented, our `TypedDict` can only have valid key
    # names.
    return cast(RawMetadata, raw), unparsed
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/requirements.py0000644000175100001730000000632714467657412024360 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import urllib.parse
from typing import Any, List, Optional, Set

from ._parser import parse_requirement as _parse_requirement
from ._tokenizer import ParserSyntaxError
from .markers import Marker, _normalize_extra_values
from .specifiers import SpecifierSet


class InvalidRequirement(ValueError):
    """
    An invalid requirement was found, users should refer to PEP 508.
    """


class Requirement:
    """Parse a requirement.

    Parse a given requirement string into its parts, such as name, specifier,
    URL, and extras. Raises InvalidRequirement on a badly-formed requirement
    string.
    """

    # TODO: Can we test whether something is contained within a requirement?
    #       If so how do we do that? Do we need to test against the _name_ of
    #       the thing as well as the version? What about the markers?
    # TODO: Can we normalize the name and extra name?

    def __init__(self, requirement_string: str) -> None:
        try:
            parsed = _parse_requirement(requirement_string)
        except ParserSyntaxError as e:
            raise InvalidRequirement(str(e)) from e

        self.name: str = parsed.name
        if parsed.url:
            parsed_url = urllib.parse.urlparse(parsed.url)
            if parsed_url.scheme == "file":
                if urllib.parse.urlunparse(parsed_url) != parsed.url:
                    raise InvalidRequirement("Invalid URL given")
            elif not (parsed_url.scheme and parsed_url.netloc) or (
                not parsed_url.scheme and not parsed_url.netloc
            ):
                raise InvalidRequirement(f"Invalid URL: {parsed.url}")
            self.url: Optional[str] = parsed.url
        else:
            self.url = None
        self.extras: Set[str] = set(parsed.extras if parsed.extras else [])
        self.specifier: SpecifierSet = SpecifierSet(parsed.specifier)
        self.marker: Optional[Marker] = None
        if parsed.marker is not None:
            self.marker = Marker.__new__(Marker)
            self.marker._markers = _normalize_extra_values(parsed.marker)

    def __str__(self) -> str:
        parts: List[str] = [self.name]

        if self.extras:
            formatted_extras = ",".join(sorted(self.extras))
            parts.append(f"[{formatted_extras}]")

        if self.specifier:
            parts.append(str(self.specifier))

        if self.url:
            parts.append(f"@ {self.url}")
            if self.marker:
                parts.append(" ")

        if self.marker:
            parts.append(f"; {self.marker}")

        return "".join(parts)

    def __repr__(self) -> str:
        return f""

    def __hash__(self) -> int:
        return hash((self.__class__.__name__, str(self)))

    def __eq__(self, other: Any) -> bool:
        if not isinstance(other, Requirement):
            return NotImplemented

        return (
            self.name == other.name
            and self.extras == other.extras
            and self.specifier == other.specifier
            and self.url == other.url
            and self.marker == other.marker
        )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/specifiers.py0000644000175100001730000011444614467657412023773 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.
"""
.. testsetup::

    from packaging.specifiers import Specifier, SpecifierSet, InvalidSpecifier
    from packaging.version import Version
"""

import abc
import itertools
import re
from typing import (
    Callable,
    Iterable,
    Iterator,
    List,
    Optional,
    Set,
    Tuple,
    TypeVar,
    Union,
)

from .utils import canonicalize_version
from .version import Version

UnparsedVersion = Union[Version, str]
UnparsedVersionVar = TypeVar("UnparsedVersionVar", bound=UnparsedVersion)
CallableOperator = Callable[[Version, str], bool]


def _coerce_version(version: UnparsedVersion) -> Version:
    if not isinstance(version, Version):
        version = Version(version)
    return version


class InvalidSpecifier(ValueError):
    """
    Raised when attempting to create a :class:`Specifier` with a specifier
    string that is invalid.

    >>> Specifier("lolwat")
    Traceback (most recent call last):
        ...
    packaging.specifiers.InvalidSpecifier: Invalid specifier: 'lolwat'
    """


class BaseSpecifier(metaclass=abc.ABCMeta):
    @abc.abstractmethod
    def __str__(self) -> str:
        """
        Returns the str representation of this Specifier-like object. This
        should be representative of the Specifier itself.
        """

    @abc.abstractmethod
    def __hash__(self) -> int:
        """
        Returns a hash value for this Specifier-like object.
        """

    @abc.abstractmethod
    def __eq__(self, other: object) -> bool:
        """
        Returns a boolean representing whether or not the two Specifier-like
        objects are equal.

        :param other: The other object to check against.
        """

    @property
    @abc.abstractmethod
    def prereleases(self) -> Optional[bool]:
        """Whether or not pre-releases as a whole are allowed.

        This can be set to either ``True`` or ``False`` to explicitly enable or disable
        prereleases or it can be set to ``None`` (the default) to use default semantics.
        """

    @prereleases.setter
    def prereleases(self, value: bool) -> None:
        """Setter for :attr:`prereleases`.

        :param value: The value to set.
        """

    @abc.abstractmethod
    def contains(self, item: str, prereleases: Optional[bool] = None) -> bool:
        """
        Determines if the given item is contained within this specifier.
        """

    @abc.abstractmethod
    def filter(
        self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None
    ) -> Iterator[UnparsedVersionVar]:
        """
        Takes an iterable of items and filters them so that only items which
        are contained within this specifier are allowed in it.
        """


class Specifier(BaseSpecifier):
    """This class abstracts handling of version specifiers.

    .. tip::

        It is generally not required to instantiate this manually. You should instead
        prefer to work with :class:`SpecifierSet` instead, which can parse
        comma-separated version specifiers (which is what package metadata contains).
    """

    _operator_regex_str = r"""
        (?P(~=|==|!=|<=|>=|<|>|===))
        """
    _version_regex_str = r"""
        (?P
            (?:
                # The identity operators allow for an escape hatch that will
                # do an exact string match of the version you wish to install.
                # This will not be parsed by PEP 440 and we cannot determine
                # any semantic meaning from it. This operator is discouraged
                # but included entirely as an escape hatch.
                (?<====)  # Only match for the identity operator
                \s*
                [^\s;)]*  # The arbitrary version can be just about anything,
                          # we match everything except for whitespace, a
                          # semi-colon for marker support, and a closing paren
                          # since versions can be enclosed in them.
            )
            |
            (?:
                # The (non)equality operators allow for wild card and local
                # versions to be specified so we have to define these two
                # operators separately to enable that.
                (?<===|!=)            # Only match for equals and not equals

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)*   # release

                # You cannot use a wild card and a pre-release, post-release, a dev or
                # local version together so group them with a | and make them optional.
                (?:
                    \.\*  # Wild card syntax of .*
                    |
                    (?:                                  # pre release
                        [-_\.]?
                        (alpha|beta|preview|pre|a|b|c|rc)
                        [-_\.]?
                        [0-9]*
                    )?
                    (?:                                  # post release
                        (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                    )?
                    (?:[-_\.]?dev[-_\.]?[0-9]*)?         # dev release
                    (?:\+[a-z0-9]+(?:[-_\.][a-z0-9]+)*)? # local
                )?
            )
            |
            (?:
                # The compatible operator requires at least two digits in the
                # release segment.
                (?<=~=)               # Only match for the compatible operator

                \s*
                v?
                (?:[0-9]+!)?          # epoch
                [0-9]+(?:\.[0-9]+)+   # release  (We have a + instead of a *)
                (?:                   # pre release
                    [-_\.]?
                    (alpha|beta|preview|pre|a|b|c|rc)
                    [-_\.]?
                    [0-9]*
                )?
                (?:                                   # post release
                    (?:-[0-9]+)|(?:[-_\.]?(post|rev|r)[-_\.]?[0-9]*)
                )?
                (?:[-_\.]?dev[-_\.]?[0-9]*)?          # dev release
            )
            |
            (?:
                # All other operators only allow a sub set of what the
                # (non)equality operators do. Specifically they do not allow
                # local versions to be specified nor do they allow the prefix
                # matching wild cards.
                (?=": "greater_than_equal",
        "<": "less_than",
        ">": "greater_than",
        "===": "arbitrary",
    }

    def __init__(self, spec: str = "", prereleases: Optional[bool] = None) -> None:
        """Initialize a Specifier instance.

        :param spec:
            The string representation of a specifier which will be parsed and
            normalized before use.
        :param prereleases:
            This tells the specifier if it should accept prerelease versions if
            applicable or not. The default of ``None`` will autodetect it from the
            given specifiers.
        :raises InvalidSpecifier:
            If the given specifier is invalid (i.e. bad syntax).
        """
        match = self._regex.search(spec)
        if not match:
            raise InvalidSpecifier(f"Invalid specifier: '{spec}'")

        self._spec: Tuple[str, str] = (
            match.group("operator").strip(),
            match.group("version").strip(),
        )

        # Store whether or not this Specifier should accept prereleases
        self._prereleases = prereleases

    # https://github.com/python/mypy/pull/13475#pullrequestreview-1079784515
    @property  # type: ignore[override]
    def prereleases(self) -> bool:
        # If there is an explicit prereleases set for this, then we'll just
        # blindly use that.
        if self._prereleases is not None:
            return self._prereleases

        # Look at all of our specifiers and determine if they are inclusive
        # operators, and if they are if they are including an explicit
        # prerelease.
        operator, version = self._spec
        if operator in ["==", ">=", "<=", "~=", "==="]:
            # The == specifier can include a trailing .*, if it does we
            # want to remove before parsing.
            if operator == "==" and version.endswith(".*"):
                version = version[:-2]

            # Parse the version, and if it is a pre-release than this
            # specifier allows pre-releases.
            if Version(version).is_prerelease:
                return True

        return False

    @prereleases.setter
    def prereleases(self, value: bool) -> None:
        self._prereleases = value

    @property
    def operator(self) -> str:
        """The operator of this specifier.

        >>> Specifier("==1.2.3").operator
        '=='
        """
        return self._spec[0]

    @property
    def version(self) -> str:
        """The version of this specifier.

        >>> Specifier("==1.2.3").version
        '1.2.3'
        """
        return self._spec[1]

    def __repr__(self) -> str:
        """A representation of the Specifier that shows all internal state.

        >>> Specifier('>=1.0.0')
        =1.0.0')>
        >>> Specifier('>=1.0.0', prereleases=False)
        =1.0.0', prereleases=False)>
        >>> Specifier('>=1.0.0', prereleases=True)
        =1.0.0', prereleases=True)>
        """
        pre = (
            f", prereleases={self.prereleases!r}"
            if self._prereleases is not None
            else ""
        )

        return f"<{self.__class__.__name__}({str(self)!r}{pre})>"

    def __str__(self) -> str:
        """A string representation of the Specifier that can be round-tripped.

        >>> str(Specifier('>=1.0.0'))
        '>=1.0.0'
        >>> str(Specifier('>=1.0.0', prereleases=False))
        '>=1.0.0'
        """
        return "{}{}".format(*self._spec)

    @property
    def _canonical_spec(self) -> Tuple[str, str]:
        canonical_version = canonicalize_version(
            self._spec[1],
            strip_trailing_zero=(self._spec[0] != "~="),
        )
        return self._spec[0], canonical_version

    def __hash__(self) -> int:
        return hash(self._canonical_spec)

    def __eq__(self, other: object) -> bool:
        """Whether or not the two Specifier-like objects are equal.

        :param other: The other object to check against.

        The value of :attr:`prereleases` is ignored.

        >>> Specifier("==1.2.3") == Specifier("== 1.2.3.0")
        True
        >>> (Specifier("==1.2.3", prereleases=False) ==
        ...  Specifier("==1.2.3", prereleases=True))
        True
        >>> Specifier("==1.2.3") == "==1.2.3"
        True
        >>> Specifier("==1.2.3") == Specifier("==1.2.4")
        False
        >>> Specifier("==1.2.3") == Specifier("~=1.2.3")
        False
        """
        if isinstance(other, str):
            try:
                other = self.__class__(str(other))
            except InvalidSpecifier:
                return NotImplemented
        elif not isinstance(other, self.__class__):
            return NotImplemented

        return self._canonical_spec == other._canonical_spec

    def _get_operator(self, op: str) -> CallableOperator:
        operator_callable: CallableOperator = getattr(
            self, f"_compare_{self._operators[op]}"
        )
        return operator_callable

    def _compare_compatible(self, prospective: Version, spec: str) -> bool:

        # Compatible releases have an equivalent combination of >= and ==. That
        # is that ~=2.2 is equivalent to >=2.2,==2.*. This allows us to
        # implement this in terms of the other specifiers instead of
        # implementing it ourselves. The only thing we need to do is construct
        # the other specifiers.

        # We want everything but the last item in the version, but we want to
        # ignore suffix segments.
        prefix = ".".join(
            list(itertools.takewhile(_is_not_suffix, _version_split(spec)))[:-1]
        )

        # Add the prefix notation to the end of our string
        prefix += ".*"

        return self._get_operator(">=")(prospective, spec) and self._get_operator("==")(
            prospective, prefix
        )

    def _compare_equal(self, prospective: Version, spec: str) -> bool:

        # We need special logic to handle prefix matching
        if spec.endswith(".*"):
            # In the case of prefix matching we want to ignore local segment.
            normalized_prospective = canonicalize_version(
                prospective.public, strip_trailing_zero=False
            )
            # Get the normalized version string ignoring the trailing .*
            normalized_spec = canonicalize_version(spec[:-2], strip_trailing_zero=False)
            # Split the spec out by dots, and pretend that there is an implicit
            # dot in between a release segment and a pre-release segment.
            split_spec = _version_split(normalized_spec)

            # Split the prospective version out by dots, and pretend that there
            # is an implicit dot in between a release segment and a pre-release
            # segment.
            split_prospective = _version_split(normalized_prospective)

            # 0-pad the prospective version before shortening it to get the correct
            # shortened version.
            padded_prospective, _ = _pad_version(split_prospective, split_spec)

            # Shorten the prospective version to be the same length as the spec
            # so that we can determine if the specifier is a prefix of the
            # prospective version or not.
            shortened_prospective = padded_prospective[: len(split_spec)]

            return shortened_prospective == split_spec
        else:
            # Convert our spec string into a Version
            spec_version = Version(spec)

            # If the specifier does not have a local segment, then we want to
            # act as if the prospective version also does not have a local
            # segment.
            if not spec_version.local:
                prospective = Version(prospective.public)

            return prospective == spec_version

    def _compare_not_equal(self, prospective: Version, spec: str) -> bool:
        return not self._compare_equal(prospective, spec)

    def _compare_less_than_equal(self, prospective: Version, spec: str) -> bool:

        # NB: Local version identifiers are NOT permitted in the version
        # specifier, so local version labels can be universally removed from
        # the prospective version.
        return Version(prospective.public) <= Version(spec)

    def _compare_greater_than_equal(self, prospective: Version, spec: str) -> bool:

        # NB: Local version identifiers are NOT permitted in the version
        # specifier, so local version labels can be universally removed from
        # the prospective version.
        return Version(prospective.public) >= Version(spec)

    def _compare_less_than(self, prospective: Version, spec_str: str) -> bool:

        # Convert our spec to a Version instance, since we'll want to work with
        # it as a version.
        spec = Version(spec_str)

        # Check to see if the prospective version is less than the spec
        # version. If it's not we can short circuit and just return False now
        # instead of doing extra unneeded work.
        if not prospective < spec:
            return False

        # This special case is here so that, unless the specifier itself
        # includes is a pre-release version, that we do not accept pre-release
        # versions for the version mentioned in the specifier (e.g. <3.1 should
        # not match 3.1.dev0, but should match 3.0.dev0).
        if not spec.is_prerelease and prospective.is_prerelease:
            if Version(prospective.base_version) == Version(spec.base_version):
                return False

        # If we've gotten to here, it means that prospective version is both
        # less than the spec version *and* it's not a pre-release of the same
        # version in the spec.
        return True

    def _compare_greater_than(self, prospective: Version, spec_str: str) -> bool:

        # Convert our spec to a Version instance, since we'll want to work with
        # it as a version.
        spec = Version(spec_str)

        # Check to see if the prospective version is greater than the spec
        # version. If it's not we can short circuit and just return False now
        # instead of doing extra unneeded work.
        if not prospective > spec:
            return False

        # This special case is here so that, unless the specifier itself
        # includes is a post-release version, that we do not accept
        # post-release versions for the version mentioned in the specifier
        # (e.g. >3.1 should not match 3.0.post0, but should match 3.2.post0).
        if not spec.is_postrelease and prospective.is_postrelease:
            if Version(prospective.base_version) == Version(spec.base_version):
                return False

        # Ensure that we do not allow a local version of the version mentioned
        # in the specifier, which is technically greater than, to match.
        if prospective.local is not None:
            if Version(prospective.base_version) == Version(spec.base_version):
                return False

        # If we've gotten to here, it means that prospective version is both
        # greater than the spec version *and* it's not a pre-release of the
        # same version in the spec.
        return True

    def _compare_arbitrary(self, prospective: Version, spec: str) -> bool:
        return str(prospective).lower() == str(spec).lower()

    def __contains__(self, item: Union[str, Version]) -> bool:
        """Return whether or not the item is contained in this specifier.

        :param item: The item to check for.

        This is used for the ``in`` operator and behaves the same as
        :meth:`contains` with no ``prereleases`` argument passed.

        >>> "1.2.3" in Specifier(">=1.2.3")
        True
        >>> Version("1.2.3") in Specifier(">=1.2.3")
        True
        >>> "1.0.0" in Specifier(">=1.2.3")
        False
        >>> "1.3.0a1" in Specifier(">=1.2.3")
        False
        >>> "1.3.0a1" in Specifier(">=1.2.3", prereleases=True)
        True
        """
        return self.contains(item)

    def contains(
        self, item: UnparsedVersion, prereleases: Optional[bool] = None
    ) -> bool:
        """Return whether or not the item is contained in this specifier.

        :param item:
            The item to check for, which can be a version string or a
            :class:`Version` instance.
        :param prereleases:
            Whether or not to match prereleases with this Specifier. If set to
            ``None`` (the default), it uses :attr:`prereleases` to determine
            whether or not prereleases are allowed.

        >>> Specifier(">=1.2.3").contains("1.2.3")
        True
        >>> Specifier(">=1.2.3").contains(Version("1.2.3"))
        True
        >>> Specifier(">=1.2.3").contains("1.0.0")
        False
        >>> Specifier(">=1.2.3").contains("1.3.0a1")
        False
        >>> Specifier(">=1.2.3", prereleases=True).contains("1.3.0a1")
        True
        >>> Specifier(">=1.2.3").contains("1.3.0a1", prereleases=True)
        True
        """

        # Determine if prereleases are to be allowed or not.
        if prereleases is None:
            prereleases = self.prereleases

        # Normalize item to a Version, this allows us to have a shortcut for
        # "2.0" in Specifier(">=2")
        normalized_item = _coerce_version(item)

        # Determine if we should be supporting prereleases in this specifier
        # or not, if we do not support prereleases than we can short circuit
        # logic if this version is a prereleases.
        if normalized_item.is_prerelease and not prereleases:
            return False

        # Actually do the comparison to determine if this item is contained
        # within this Specifier or not.
        operator_callable: CallableOperator = self._get_operator(self.operator)
        return operator_callable(normalized_item, self.version)

    def filter(
        self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None
    ) -> Iterator[UnparsedVersionVar]:
        """Filter items in the given iterable, that match the specifier.

        :param iterable:
            An iterable that can contain version strings and :class:`Version` instances.
            The items in the iterable will be filtered according to the specifier.
        :param prereleases:
            Whether or not to allow prereleases in the returned iterator. If set to
            ``None`` (the default), it will be intelligently decide whether to allow
            prereleases or not (based on the :attr:`prereleases` attribute, and
            whether the only versions matching are prereleases).

        This method is smarter than just ``filter(Specifier().contains, [...])``
        because it implements the rule from :pep:`440` that a prerelease item
        SHOULD be accepted if no other versions match the given specifier.

        >>> list(Specifier(">=1.2.3").filter(["1.2", "1.3", "1.5a1"]))
        ['1.3']
        >>> list(Specifier(">=1.2.3").filter(["1.2", "1.2.3", "1.3", Version("1.4")]))
        ['1.2.3', '1.3', ]
        >>> list(Specifier(">=1.2.3").filter(["1.2", "1.5a1"]))
        ['1.5a1']
        >>> list(Specifier(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True))
        ['1.3', '1.5a1']
        >>> list(Specifier(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"]))
        ['1.3', '1.5a1']
        """

        yielded = False
        found_prereleases = []

        kw = {"prereleases": prereleases if prereleases is not None else True}

        # Attempt to iterate over all the values in the iterable and if any of
        # them match, yield them.
        for version in iterable:
            parsed_version = _coerce_version(version)

            if self.contains(parsed_version, **kw):
                # If our version is a prerelease, and we were not set to allow
                # prereleases, then we'll store it for later in case nothing
                # else matches this specifier.
                if parsed_version.is_prerelease and not (
                    prereleases or self.prereleases
                ):
                    found_prereleases.append(version)
                # Either this is not a prerelease, or we should have been
                # accepting prereleases from the beginning.
                else:
                    yielded = True
                    yield version

        # Now that we've iterated over everything, determine if we've yielded
        # any values, and if we have not and we have any prereleases stored up
        # then we will go ahead and yield the prereleases.
        if not yielded and found_prereleases:
            for version in found_prereleases:
                yield version


_prefix_regex = re.compile(r"^([0-9]+)((?:a|b|c|rc)[0-9]+)$")


def _version_split(version: str) -> List[str]:
    result: List[str] = []
    for item in version.split("."):
        match = _prefix_regex.search(item)
        if match:
            result.extend(match.groups())
        else:
            result.append(item)
    return result


def _is_not_suffix(segment: str) -> bool:
    return not any(
        segment.startswith(prefix) for prefix in ("dev", "a", "b", "rc", "post")
    )


def _pad_version(left: List[str], right: List[str]) -> Tuple[List[str], List[str]]:
    left_split, right_split = [], []

    # Get the release segment of our versions
    left_split.append(list(itertools.takewhile(lambda x: x.isdigit(), left)))
    right_split.append(list(itertools.takewhile(lambda x: x.isdigit(), right)))

    # Get the rest of our versions
    left_split.append(left[len(left_split[0]) :])
    right_split.append(right[len(right_split[0]) :])

    # Insert our padding
    left_split.insert(1, ["0"] * max(0, len(right_split[0]) - len(left_split[0])))
    right_split.insert(1, ["0"] * max(0, len(left_split[0]) - len(right_split[0])))

    return (list(itertools.chain(*left_split)), list(itertools.chain(*right_split)))


class SpecifierSet(BaseSpecifier):
    """This class abstracts handling of a set of version specifiers.

    It can be passed a single specifier (``>=3.0``), a comma-separated list of
    specifiers (``>=3.0,!=3.1``), or no specifier at all.
    """

    def __init__(
        self, specifiers: str = "", prereleases: Optional[bool] = None
    ) -> None:
        """Initialize a SpecifierSet instance.

        :param specifiers:
            The string representation of a specifier or a comma-separated list of
            specifiers which will be parsed and normalized before use.
        :param prereleases:
            This tells the SpecifierSet if it should accept prerelease versions if
            applicable or not. The default of ``None`` will autodetect it from the
            given specifiers.

        :raises InvalidSpecifier:
            If the given ``specifiers`` are not parseable than this exception will be
            raised.
        """

        # Split on `,` to break each individual specifier into it's own item, and
        # strip each item to remove leading/trailing whitespace.
        split_specifiers = [s.strip() for s in specifiers.split(",") if s.strip()]

        # Parsed each individual specifier, attempting first to make it a
        # Specifier.
        parsed: Set[Specifier] = set()
        for specifier in split_specifiers:
            parsed.add(Specifier(specifier))

        # Turn our parsed specifiers into a frozen set and save them for later.
        self._specs = frozenset(parsed)

        # Store our prereleases value so we can use it later to determine if
        # we accept prereleases or not.
        self._prereleases = prereleases

    @property
    def prereleases(self) -> Optional[bool]:
        # If we have been given an explicit prerelease modifier, then we'll
        # pass that through here.
        if self._prereleases is not None:
            return self._prereleases

        # If we don't have any specifiers, and we don't have a forced value,
        # then we'll just return None since we don't know if this should have
        # pre-releases or not.
        if not self._specs:
            return None

        # Otherwise we'll see if any of the given specifiers accept
        # prereleases, if any of them do we'll return True, otherwise False.
        return any(s.prereleases for s in self._specs)

    @prereleases.setter
    def prereleases(self, value: bool) -> None:
        self._prereleases = value

    def __repr__(self) -> str:
        """A representation of the specifier set that shows all internal state.

        Note that the ordering of the individual specifiers within the set may not
        match the input string.

        >>> SpecifierSet('>=1.0.0,!=2.0.0')
        =1.0.0')>
        >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=False)
        =1.0.0', prereleases=False)>
        >>> SpecifierSet('>=1.0.0,!=2.0.0', prereleases=True)
        =1.0.0', prereleases=True)>
        """
        pre = (
            f", prereleases={self.prereleases!r}"
            if self._prereleases is not None
            else ""
        )

        return f""

    def __str__(self) -> str:
        """A string representation of the specifier set that can be round-tripped.

        Note that the ordering of the individual specifiers within the set may not
        match the input string.

        >>> str(SpecifierSet(">=1.0.0,!=1.0.1"))
        '!=1.0.1,>=1.0.0'
        >>> str(SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False))
        '!=1.0.1,>=1.0.0'
        """
        return ",".join(sorted(str(s) for s in self._specs))

    def __hash__(self) -> int:
        return hash(self._specs)

    def __and__(self, other: Union["SpecifierSet", str]) -> "SpecifierSet":
        """Return a SpecifierSet which is a combination of the two sets.

        :param other: The other object to combine with.

        >>> SpecifierSet(">=1.0.0,!=1.0.1") & '<=2.0.0,!=2.0.1'
        =1.0.0')>
        >>> SpecifierSet(">=1.0.0,!=1.0.1") & SpecifierSet('<=2.0.0,!=2.0.1')
        =1.0.0')>
        """
        if isinstance(other, str):
            other = SpecifierSet(other)
        elif not isinstance(other, SpecifierSet):
            return NotImplemented

        specifier = SpecifierSet()
        specifier._specs = frozenset(self._specs | other._specs)

        if self._prereleases is None and other._prereleases is not None:
            specifier._prereleases = other._prereleases
        elif self._prereleases is not None and other._prereleases is None:
            specifier._prereleases = self._prereleases
        elif self._prereleases == other._prereleases:
            specifier._prereleases = self._prereleases
        else:
            raise ValueError(
                "Cannot combine SpecifierSets with True and False prerelease "
                "overrides."
            )

        return specifier

    def __eq__(self, other: object) -> bool:
        """Whether or not the two SpecifierSet-like objects are equal.

        :param other: The other object to check against.

        The value of :attr:`prereleases` is ignored.

        >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.1")
        True
        >>> (SpecifierSet(">=1.0.0,!=1.0.1", prereleases=False) ==
        ...  SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True))
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1") == ">=1.0.0,!=1.0.1"
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0")
        False
        >>> SpecifierSet(">=1.0.0,!=1.0.1") == SpecifierSet(">=1.0.0,!=1.0.2")
        False
        """
        if isinstance(other, (str, Specifier)):
            other = SpecifierSet(str(other))
        elif not isinstance(other, SpecifierSet):
            return NotImplemented

        return self._specs == other._specs

    def __len__(self) -> int:
        """Returns the number of specifiers in this specifier set."""
        return len(self._specs)

    def __iter__(self) -> Iterator[Specifier]:
        """
        Returns an iterator over all the underlying :class:`Specifier` instances
        in this specifier set.

        >>> sorted(SpecifierSet(">=1.0.0,!=1.0.1"), key=str)
        [, =1.0.0')>]
        """
        return iter(self._specs)

    def __contains__(self, item: UnparsedVersion) -> bool:
        """Return whether or not the item is contained in this specifier.

        :param item: The item to check for.

        This is used for the ``in`` operator and behaves the same as
        :meth:`contains` with no ``prereleases`` argument passed.

        >>> "1.2.3" in SpecifierSet(">=1.0.0,!=1.0.1")
        True
        >>> Version("1.2.3") in SpecifierSet(">=1.0.0,!=1.0.1")
        True
        >>> "1.0.1" in SpecifierSet(">=1.0.0,!=1.0.1")
        False
        >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1")
        False
        >>> "1.3.0a1" in SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True)
        True
        """
        return self.contains(item)

    def contains(
        self,
        item: UnparsedVersion,
        prereleases: Optional[bool] = None,
        installed: Optional[bool] = None,
    ) -> bool:
        """Return whether or not the item is contained in this SpecifierSet.

        :param item:
            The item to check for, which can be a version string or a
            :class:`Version` instance.
        :param prereleases:
            Whether or not to match prereleases with this SpecifierSet. If set to
            ``None`` (the default), it uses :attr:`prereleases` to determine
            whether or not prereleases are allowed.

        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.2.3")
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains(Version("1.2.3"))
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.0.1")
        False
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1")
        False
        >>> SpecifierSet(">=1.0.0,!=1.0.1", prereleases=True).contains("1.3.0a1")
        True
        >>> SpecifierSet(">=1.0.0,!=1.0.1").contains("1.3.0a1", prereleases=True)
        True
        """
        # Ensure that our item is a Version instance.
        if not isinstance(item, Version):
            item = Version(item)

        # Determine if we're forcing a prerelease or not, if we're not forcing
        # one for this particular filter call, then we'll use whatever the
        # SpecifierSet thinks for whether or not we should support prereleases.
        if prereleases is None:
            prereleases = self.prereleases

        # We can determine if we're going to allow pre-releases by looking to
        # see if any of the underlying items supports them. If none of them do
        # and this item is a pre-release then we do not allow it and we can
        # short circuit that here.
        # Note: This means that 1.0.dev1 would not be contained in something
        #       like >=1.0.devabc however it would be in >=1.0.debabc,>0.0.dev0
        if not prereleases and item.is_prerelease:
            return False

        if installed and item.is_prerelease:
            item = Version(item.base_version)

        # We simply dispatch to the underlying specs here to make sure that the
        # given version is contained within all of them.
        # Note: This use of all() here means that an empty set of specifiers
        #       will always return True, this is an explicit design decision.
        return all(s.contains(item, prereleases=prereleases) for s in self._specs)

    def filter(
        self, iterable: Iterable[UnparsedVersionVar], prereleases: Optional[bool] = None
    ) -> Iterator[UnparsedVersionVar]:
        """Filter items in the given iterable, that match the specifiers in this set.

        :param iterable:
            An iterable that can contain version strings and :class:`Version` instances.
            The items in the iterable will be filtered according to the specifier.
        :param prereleases:
            Whether or not to allow prereleases in the returned iterator. If set to
            ``None`` (the default), it will be intelligently decide whether to allow
            prereleases or not (based on the :attr:`prereleases` attribute, and
            whether the only versions matching are prereleases).

        This method is smarter than just ``filter(SpecifierSet(...).contains, [...])``
        because it implements the rule from :pep:`440` that a prerelease item
        SHOULD be accepted if no other versions match the given specifier.

        >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", "1.5a1"]))
        ['1.3']
        >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.3", Version("1.4")]))
        ['1.3', ]
        >>> list(SpecifierSet(">=1.2.3").filter(["1.2", "1.5a1"]))
        []
        >>> list(SpecifierSet(">=1.2.3").filter(["1.3", "1.5a1"], prereleases=True))
        ['1.3', '1.5a1']
        >>> list(SpecifierSet(">=1.2.3", prereleases=True).filter(["1.3", "1.5a1"]))
        ['1.3', '1.5a1']

        An "empty" SpecifierSet will filter items based on the presence of prerelease
        versions in the set.

        >>> list(SpecifierSet("").filter(["1.3", "1.5a1"]))
        ['1.3']
        >>> list(SpecifierSet("").filter(["1.5a1"]))
        ['1.5a1']
        >>> list(SpecifierSet("", prereleases=True).filter(["1.3", "1.5a1"]))
        ['1.3', '1.5a1']
        >>> list(SpecifierSet("").filter(["1.3", "1.5a1"], prereleases=True))
        ['1.3', '1.5a1']
        """
        # Determine if we're forcing a prerelease or not, if we're not forcing
        # one for this particular filter call, then we'll use whatever the
        # SpecifierSet thinks for whether or not we should support prereleases.
        if prereleases is None:
            prereleases = self.prereleases

        # If we have any specifiers, then we want to wrap our iterable in the
        # filter method for each one, this will act as a logical AND amongst
        # each specifier.
        if self._specs:
            for spec in self._specs:
                iterable = spec.filter(iterable, prereleases=bool(prereleases))
            return iter(iterable)
        # If we do not have any specifiers, then we need to have a rough filter
        # which will filter out any pre-releases, unless there are no final
        # releases.
        else:
            filtered: List[UnparsedVersionVar] = []
            found_prereleases: List[UnparsedVersionVar] = []

            for item in iterable:
                parsed_version = _coerce_version(item)

                # Store any item which is a pre-release for later unless we've
                # already found a final version or we are accepting prereleases
                if parsed_version.is_prerelease and not prereleases:
                    if not filtered:
                        found_prereleases.append(item)
                else:
                    filtered.append(item)

            # If we've found no items except for pre-releases, then we'll go
            # ahead and use the pre-releases
            if not filtered and found_prereleases and prereleases is None:
                return iter(found_prereleases)

            return iter(filtered)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/tags.py0000644000175100001730000004327214467657412022573 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import logging
import platform
import subprocess
import sys
import sysconfig
from importlib.machinery import EXTENSION_SUFFIXES
from typing import (
    Dict,
    FrozenSet,
    Iterable,
    Iterator,
    List,
    Optional,
    Sequence,
    Tuple,
    Union,
    cast,
)

from . import _manylinux, _musllinux

logger = logging.getLogger(__name__)

PythonVersion = Sequence[int]
MacVersion = Tuple[int, int]

INTERPRETER_SHORT_NAMES: Dict[str, str] = {
    "python": "py",  # Generic.
    "cpython": "cp",
    "pypy": "pp",
    "ironpython": "ip",
    "jython": "jy",
}


_32_BIT_INTERPRETER = sys.maxsize <= 2**32


class Tag:
    """
    A representation of the tag triple for a wheel.

    Instances are considered immutable and thus are hashable. Equality checking
    is also supported.
    """

    __slots__ = ["_interpreter", "_abi", "_platform", "_hash"]

    def __init__(self, interpreter: str, abi: str, platform: str) -> None:
        self._interpreter = interpreter.lower()
        self._abi = abi.lower()
        self._platform = platform.lower()
        # The __hash__ of every single element in a Set[Tag] will be evaluated each time
        # that a set calls its `.disjoint()` method, which may be called hundreds of
        # times when scanning a page of links for packages with tags matching that
        # Set[Tag]. Pre-computing the value here produces significant speedups for
        # downstream consumers.
        self._hash = hash((self._interpreter, self._abi, self._platform))

    @property
    def interpreter(self) -> str:
        return self._interpreter

    @property
    def abi(self) -> str:
        return self._abi

    @property
    def platform(self) -> str:
        return self._platform

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, Tag):
            return NotImplemented

        return (
            (self._hash == other._hash)  # Short-circuit ASAP for perf reasons.
            and (self._platform == other._platform)
            and (self._abi == other._abi)
            and (self._interpreter == other._interpreter)
        )

    def __hash__(self) -> int:
        return self._hash

    def __str__(self) -> str:
        return f"{self._interpreter}-{self._abi}-{self._platform}"

    def __repr__(self) -> str:
        return f"<{self} @ {id(self)}>"


def parse_tag(tag: str) -> FrozenSet[Tag]:
    """
    Parses the provided tag (e.g. `py3-none-any`) into a frozenset of Tag instances.

    Returning a set is required due to the possibility that the tag is a
    compressed tag set.
    """
    tags = set()
    interpreters, abis, platforms = tag.split("-")
    for interpreter in interpreters.split("."):
        for abi in abis.split("."):
            for platform_ in platforms.split("."):
                tags.add(Tag(interpreter, abi, platform_))
    return frozenset(tags)


def _get_config_var(name: str, warn: bool = False) -> Union[int, str, None]:
    value: Union[int, str, None] = sysconfig.get_config_var(name)
    if value is None and warn:
        logger.debug(
            "Config variable '%s' is unset, Python ABI tag may be incorrect", name
        )
    return value


def _normalize_string(string: str) -> str:
    return string.replace(".", "_").replace("-", "_").replace(" ", "_")


def _abi3_applies(python_version: PythonVersion) -> bool:
    """
    Determine if the Python version supports abi3.

    PEP 384 was first implemented in Python 3.2.
    """
    return len(python_version) > 1 and tuple(python_version) >= (3, 2)


def _cpython_abis(py_version: PythonVersion, warn: bool = False) -> List[str]:
    py_version = tuple(py_version)  # To allow for version comparison.
    abis = []
    version = _version_nodot(py_version[:2])
    debug = pymalloc = ucs4 = ""
    with_debug = _get_config_var("Py_DEBUG", warn)
    has_refcount = hasattr(sys, "gettotalrefcount")
    # Windows doesn't set Py_DEBUG, so checking for support of debug-compiled
    # extension modules is the best option.
    # https://github.com/pypa/pip/issues/3383#issuecomment-173267692
    has_ext = "_d.pyd" in EXTENSION_SUFFIXES
    if with_debug or (with_debug is None and (has_refcount or has_ext)):
        debug = "d"
    if py_version < (3, 8):
        with_pymalloc = _get_config_var("WITH_PYMALLOC", warn)
        if with_pymalloc or with_pymalloc is None:
            pymalloc = "m"
        if py_version < (3, 3):
            unicode_size = _get_config_var("Py_UNICODE_SIZE", warn)
            if unicode_size == 4 or (
                unicode_size is None and sys.maxunicode == 0x10FFFF
            ):
                ucs4 = "u"
    elif debug:
        # Debug builds can also load "normal" extension modules.
        # We can also assume no UCS-4 or pymalloc requirement.
        abis.append(f"cp{version}")
    abis.insert(
        0,
        "cp{version}{debug}{pymalloc}{ucs4}".format(
            version=version, debug=debug, pymalloc=pymalloc, ucs4=ucs4
        ),
    )
    return abis


def cpython_tags(
    python_version: Optional[PythonVersion] = None,
    abis: Optional[Iterable[str]] = None,
    platforms: Optional[Iterable[str]] = None,
    *,
    warn: bool = False,
) -> Iterator[Tag]:
    """
    Yields the tags for a CPython interpreter.

    The tags consist of:
    - cp--
    - cp-abi3-
    - cp-none-
    - cp-abi3-  # Older Python versions down to 3.2.

    If python_version only specifies a major version then user-provided ABIs and
    the 'none' ABItag will be used.

    If 'abi3' or 'none' are specified in 'abis' then they will be yielded at
    their normal position and not at the beginning.
    """
    if not python_version:
        python_version = sys.version_info[:2]

    interpreter = f"cp{_version_nodot(python_version[:2])}"

    if abis is None:
        if len(python_version) > 1:
            abis = _cpython_abis(python_version, warn)
        else:
            abis = []
    abis = list(abis)
    # 'abi3' and 'none' are explicitly handled later.
    for explicit_abi in ("abi3", "none"):
        try:
            abis.remove(explicit_abi)
        except ValueError:
            pass

    platforms = list(platforms or platform_tags())
    for abi in abis:
        for platform_ in platforms:
            yield Tag(interpreter, abi, platform_)
    if _abi3_applies(python_version):
        yield from (Tag(interpreter, "abi3", platform_) for platform_ in platforms)
    yield from (Tag(interpreter, "none", platform_) for platform_ in platforms)

    if _abi3_applies(python_version):
        for minor_version in range(python_version[1] - 1, 1, -1):
            for platform_ in platforms:
                interpreter = "cp{version}".format(
                    version=_version_nodot((python_version[0], minor_version))
                )
                yield Tag(interpreter, "abi3", platform_)


def _generic_abi() -> List[str]:
    """
    Return the ABI tag based on EXT_SUFFIX.
    """
    # The following are examples of `EXT_SUFFIX`.
    # We want to keep the parts which are related to the ABI and remove the
    # parts which are related to the platform:
    # - linux:   '.cpython-310-x86_64-linux-gnu.so' => cp310
    # - mac:     '.cpython-310-darwin.so'           => cp310
    # - win:     '.cp310-win_amd64.pyd'             => cp310
    # - win:     '.pyd'                             => cp37 (uses _cpython_abis())
    # - pypy:    '.pypy38-pp73-x86_64-linux-gnu.so' => pypy38_pp73
    # - graalpy: '.graalpy-38-native-x86_64-darwin.dylib'
    #                                               => graalpy_38_native

    ext_suffix = _get_config_var("EXT_SUFFIX", warn=True)
    if not isinstance(ext_suffix, str) or ext_suffix[0] != ".":
        raise SystemError("invalid sysconfig.get_config_var('EXT_SUFFIX')")
    parts = ext_suffix.split(".")
    if len(parts) < 3:
        # CPython3.7 and earlier uses ".pyd" on Windows.
        return _cpython_abis(sys.version_info[:2])
    soabi = parts[1]
    if soabi.startswith("cpython"):
        # non-windows
        abi = "cp" + soabi.split("-")[1]
    elif soabi.startswith("cp"):
        # windows
        abi = soabi.split("-")[0]
    elif soabi.startswith("pypy"):
        abi = "-".join(soabi.split("-")[:2])
    elif soabi.startswith("graalpy"):
        abi = "-".join(soabi.split("-")[:3])
    elif soabi:
        # pyston, ironpython, others?
        abi = soabi
    else:
        return []
    return [_normalize_string(abi)]


def generic_tags(
    interpreter: Optional[str] = None,
    abis: Optional[Iterable[str]] = None,
    platforms: Optional[Iterable[str]] = None,
    *,
    warn: bool = False,
) -> Iterator[Tag]:
    """
    Yields the tags for a generic interpreter.

    The tags consist of:
    - --

    The "none" ABI will be added if it was not explicitly provided.
    """
    if not interpreter:
        interp_name = interpreter_name()
        interp_version = interpreter_version(warn=warn)
        interpreter = "".join([interp_name, interp_version])
    if abis is None:
        abis = _generic_abi()
    else:
        abis = list(abis)
    platforms = list(platforms or platform_tags())
    if "none" not in abis:
        abis.append("none")
    for abi in abis:
        for platform_ in platforms:
            yield Tag(interpreter, abi, platform_)


def _py_interpreter_range(py_version: PythonVersion) -> Iterator[str]:
    """
    Yields Python versions in descending order.

    After the latest version, the major-only version will be yielded, and then
    all previous versions of that major version.
    """
    if len(py_version) > 1:
        yield f"py{_version_nodot(py_version[:2])}"
    yield f"py{py_version[0]}"
    if len(py_version) > 1:
        for minor in range(py_version[1] - 1, -1, -1):
            yield f"py{_version_nodot((py_version[0], minor))}"


def compatible_tags(
    python_version: Optional[PythonVersion] = None,
    interpreter: Optional[str] = None,
    platforms: Optional[Iterable[str]] = None,
) -> Iterator[Tag]:
    """
    Yields the sequence of tags that are compatible with a specific version of Python.

    The tags consist of:
    - py*-none-
    - -none-any  # ... if `interpreter` is provided.
    - py*-none-any
    """
    if not python_version:
        python_version = sys.version_info[:2]
    platforms = list(platforms or platform_tags())
    for version in _py_interpreter_range(python_version):
        for platform_ in platforms:
            yield Tag(version, "none", platform_)
    if interpreter:
        yield Tag(interpreter, "none", "any")
    for version in _py_interpreter_range(python_version):
        yield Tag(version, "none", "any")


def _mac_arch(arch: str, is_32bit: bool = _32_BIT_INTERPRETER) -> str:
    if not is_32bit:
        return arch

    if arch.startswith("ppc"):
        return "ppc"

    return "i386"


def _mac_binary_formats(version: MacVersion, cpu_arch: str) -> List[str]:
    formats = [cpu_arch]
    if cpu_arch == "x86_64":
        if version < (10, 4):
            return []
        formats.extend(["intel", "fat64", "fat32"])

    elif cpu_arch == "i386":
        if version < (10, 4):
            return []
        formats.extend(["intel", "fat32", "fat"])

    elif cpu_arch == "ppc64":
        # TODO: Need to care about 32-bit PPC for ppc64 through 10.2?
        if version > (10, 5) or version < (10, 4):
            return []
        formats.append("fat64")

    elif cpu_arch == "ppc":
        if version > (10, 6):
            return []
        formats.extend(["fat32", "fat"])

    if cpu_arch in {"arm64", "x86_64"}:
        formats.append("universal2")

    if cpu_arch in {"x86_64", "i386", "ppc64", "ppc", "intel"}:
        formats.append("universal")

    return formats


def mac_platforms(
    version: Optional[MacVersion] = None, arch: Optional[str] = None
) -> Iterator[str]:
    """
    Yields the platform tags for a macOS system.

    The `version` parameter is a two-item tuple specifying the macOS version to
    generate platform tags for. The `arch` parameter is the CPU architecture to
    generate platform tags for. Both parameters default to the appropriate value
    for the current system.
    """
    version_str, _, cpu_arch = platform.mac_ver()
    if version is None:
        version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
        if version == (10, 16):
            # When built against an older macOS SDK, Python will report macOS 10.16
            # instead of the real version.
            version_str = subprocess.run(
                [
                    sys.executable,
                    "-sS",
                    "-c",
                    "import platform; print(platform.mac_ver()[0])",
                ],
                check=True,
                env={"SYSTEM_VERSION_COMPAT": "0"},
                stdout=subprocess.PIPE,
                universal_newlines=True,
            ).stdout
            version = cast("MacVersion", tuple(map(int, version_str.split(".")[:2])))
    else:
        version = version
    if arch is None:
        arch = _mac_arch(cpu_arch)
    else:
        arch = arch

    if (10, 0) <= version and version < (11, 0):
        # Prior to Mac OS 11, each yearly release of Mac OS bumped the
        # "minor" version number.  The major version was always 10.
        for minor_version in range(version[1], -1, -1):
            compat_version = 10, minor_version
            binary_formats = _mac_binary_formats(compat_version, arch)
            for binary_format in binary_formats:
                yield "macosx_{major}_{minor}_{binary_format}".format(
                    major=10, minor=minor_version, binary_format=binary_format
                )

    if version >= (11, 0):
        # Starting with Mac OS 11, each yearly release bumps the major version
        # number.   The minor versions are now the midyear updates.
        for major_version in range(version[0], 10, -1):
            compat_version = major_version, 0
            binary_formats = _mac_binary_formats(compat_version, arch)
            for binary_format in binary_formats:
                yield "macosx_{major}_{minor}_{binary_format}".format(
                    major=major_version, minor=0, binary_format=binary_format
                )

    if version >= (11, 0):
        # Mac OS 11 on x86_64 is compatible with binaries from previous releases.
        # Arm64 support was introduced in 11.0, so no Arm binaries from previous
        # releases exist.
        #
        # However, the "universal2" binary format can have a
        # macOS version earlier than 11.0 when the x86_64 part of the binary supports
        # that version of macOS.
        if arch == "x86_64":
            for minor_version in range(16, 3, -1):
                compat_version = 10, minor_version
                binary_formats = _mac_binary_formats(compat_version, arch)
                for binary_format in binary_formats:
                    yield "macosx_{major}_{minor}_{binary_format}".format(
                        major=compat_version[0],
                        minor=compat_version[1],
                        binary_format=binary_format,
                    )
        else:
            for minor_version in range(16, 3, -1):
                compat_version = 10, minor_version
                binary_format = "universal2"
                yield "macosx_{major}_{minor}_{binary_format}".format(
                    major=compat_version[0],
                    minor=compat_version[1],
                    binary_format=binary_format,
                )


def _linux_platforms(is_32bit: bool = _32_BIT_INTERPRETER) -> Iterator[str]:
    linux = _normalize_string(sysconfig.get_platform())
    if is_32bit:
        if linux == "linux_x86_64":
            linux = "linux_i686"
        elif linux == "linux_aarch64":
            linux = "linux_armv7l"
    _, arch = linux.split("_", 1)
    yield from _manylinux.platform_tags(linux, arch)
    yield from _musllinux.platform_tags(arch)
    yield linux


def _generic_platforms() -> Iterator[str]:
    yield _normalize_string(sysconfig.get_platform())


def platform_tags() -> Iterator[str]:
    """
    Provides the platform tags for this installation.
    """
    if platform.system() == "Darwin":
        return mac_platforms()
    elif platform.system() == "Linux":
        return _linux_platforms()
    else:
        return _generic_platforms()


def interpreter_name() -> str:
    """
    Returns the name of the running interpreter.

    Some implementations have a reserved, two-letter abbreviation which will
    be returned when appropriate.
    """
    name = sys.implementation.name
    return INTERPRETER_SHORT_NAMES.get(name) or name


def interpreter_version(*, warn: bool = False) -> str:
    """
    Returns the version of the running interpreter.
    """
    version = _get_config_var("py_version_nodot", warn=warn)
    if version:
        version = str(version)
    else:
        version = _version_nodot(sys.version_info[:2])
    return version


def _version_nodot(version: PythonVersion) -> str:
    return "".join(map(str, version))


def sys_tags(*, warn: bool = False) -> Iterator[Tag]:
    """
    Returns the sequence of tag triples for the running interpreter.

    The order of the sequence corresponds to priority order for the
    interpreter, from most to least important.
    """

    interp_name = interpreter_name()
    if interp_name == "cp":
        yield from cpython_tags(warn=warn)
    else:
        yield from generic_tags()

    if interp_name == "pp":
        interp = "pp3"
    elif interp_name == "cp":
        interp = "cp" + interpreter_version(warn=warn)
    else:
        interp = None
    yield from compatible_tags(interpreter=interp)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/utils.py0000644000175100001730000001040314467657412022763 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.

import re
from typing import FrozenSet, NewType, Tuple, Union, cast

from .tags import Tag, parse_tag
from .version import InvalidVersion, Version

BuildTag = Union[Tuple[()], Tuple[int, str]]
NormalizedName = NewType("NormalizedName", str)


class InvalidWheelFilename(ValueError):
    """
    An invalid wheel filename was found, users should refer to PEP 427.
    """


class InvalidSdistFilename(ValueError):
    """
    An invalid sdist filename was found, users should refer to the packaging user guide.
    """


_canonicalize_regex = re.compile(r"[-_.]+")
# PEP 427: The build number must start with a digit.
_build_tag_regex = re.compile(r"(\d+)(.*)")


def canonicalize_name(name: str) -> NormalizedName:
    # This is taken from PEP 503.
    value = _canonicalize_regex.sub("-", name).lower()
    return cast(NormalizedName, value)


def canonicalize_version(
    version: Union[Version, str], *, strip_trailing_zero: bool = True
) -> str:
    """
    This is very similar to Version.__str__, but has one subtle difference
    with the way it handles the release segment.
    """
    if isinstance(version, str):
        try:
            parsed = Version(version)
        except InvalidVersion:
            # Legacy versions cannot be normalized
            return version
    else:
        parsed = version

    parts = []

    # Epoch
    if parsed.epoch != 0:
        parts.append(f"{parsed.epoch}!")

    # Release segment
    release_segment = ".".join(str(x) for x in parsed.release)
    if strip_trailing_zero:
        # NB: This strips trailing '.0's to normalize
        release_segment = re.sub(r"(\.0)+$", "", release_segment)
    parts.append(release_segment)

    # Pre-release
    if parsed.pre is not None:
        parts.append("".join(str(x) for x in parsed.pre))

    # Post-release
    if parsed.post is not None:
        parts.append(f".post{parsed.post}")

    # Development release
    if parsed.dev is not None:
        parts.append(f".dev{parsed.dev}")

    # Local version segment
    if parsed.local is not None:
        parts.append(f"+{parsed.local}")

    return "".join(parts)


def parse_wheel_filename(
    filename: str,
) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]:
    if not filename.endswith(".whl"):
        raise InvalidWheelFilename(
            f"Invalid wheel filename (extension must be '.whl'): {filename}"
        )

    filename = filename[:-4]
    dashes = filename.count("-")
    if dashes not in (4, 5):
        raise InvalidWheelFilename(
            f"Invalid wheel filename (wrong number of parts): {filename}"
        )

    parts = filename.split("-", dashes - 2)
    name_part = parts[0]
    # See PEP 427 for the rules on escaping the project name
    if "__" in name_part or re.match(r"^[\w\d._]*$", name_part, re.UNICODE) is None:
        raise InvalidWheelFilename(f"Invalid project name: {filename}")
    name = canonicalize_name(name_part)
    version = Version(parts[1])
    if dashes == 5:
        build_part = parts[2]
        build_match = _build_tag_regex.match(build_part)
        if build_match is None:
            raise InvalidWheelFilename(
                f"Invalid build number: {build_part} in '{filename}'"
            )
        build = cast(BuildTag, (int(build_match.group(1)), build_match.group(2)))
    else:
        build = ()
    tags = parse_tag(parts[-1])
    return (name, version, build, tags)


def parse_sdist_filename(filename: str) -> Tuple[NormalizedName, Version]:
    if filename.endswith(".tar.gz"):
        file_stem = filename[: -len(".tar.gz")]
    elif filename.endswith(".zip"):
        file_stem = filename[: -len(".zip")]
    else:
        raise InvalidSdistFilename(
            f"Invalid sdist filename (extension must be '.tar.gz' or '.zip'):"
            f" {filename}"
        )

    # We are requiring a PEP 440 version, which cannot contain dashes,
    # so we split on the last dash.
    name_part, sep, version_part = file_stem.rpartition("-")
    if not sep:
        raise InvalidSdistFilename(f"Invalid sdist filename: {filename}")

    name = canonicalize_name(name_part)
    version = Version(version_part)
    return (name, version)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/packaging/version.py0000644000175100001730000003770614467657412023327 0ustar00runnerdocker# This file is dual licensed under the terms of the Apache License, Version
# 2.0, and the BSD License. See the LICENSE file in the root of this repository
# for complete details.
"""
.. testsetup::

    from packaging.version import parse, Version
"""

import collections
import itertools
import re
from typing import Any, Callable, Optional, SupportsInt, Tuple, Union

from ._structures import Infinity, InfinityType, NegativeInfinity, NegativeInfinityType

__all__ = ["VERSION_PATTERN", "parse", "Version", "InvalidVersion"]

InfiniteTypes = Union[InfinityType, NegativeInfinityType]
PrePostDevType = Union[InfiniteTypes, Tuple[str, int]]
SubLocalType = Union[InfiniteTypes, int, str]
LocalType = Union[
    NegativeInfinityType,
    Tuple[
        Union[
            SubLocalType,
            Tuple[SubLocalType, str],
            Tuple[NegativeInfinityType, SubLocalType],
        ],
        ...,
    ],
]
CmpKey = Tuple[
    int, Tuple[int, ...], PrePostDevType, PrePostDevType, PrePostDevType, LocalType
]
VersionComparisonMethod = Callable[[CmpKey, CmpKey], bool]

_Version = collections.namedtuple(
    "_Version", ["epoch", "release", "dev", "pre", "post", "local"]
)


def parse(version: str) -> "Version":
    """Parse the given version string.

    >>> parse('1.0.dev1')
    

    :param version: The version string to parse.
    :raises InvalidVersion: When the version string is not a valid version.
    """
    return Version(version)


class InvalidVersion(ValueError):
    """Raised when a version string is not a valid version.

    >>> Version("invalid")
    Traceback (most recent call last):
        ...
    packaging.version.InvalidVersion: Invalid version: 'invalid'
    """


class _BaseVersion:
    _key: Tuple[Any, ...]

    def __hash__(self) -> int:
        return hash(self._key)

    # Please keep the duplicated `isinstance` check
    # in the six comparisons hereunder
    # unless you find a way to avoid adding overhead function calls.
    def __lt__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key < other._key

    def __le__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key <= other._key

    def __eq__(self, other: object) -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key == other._key

    def __ge__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key >= other._key

    def __gt__(self, other: "_BaseVersion") -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key > other._key

    def __ne__(self, other: object) -> bool:
        if not isinstance(other, _BaseVersion):
            return NotImplemented

        return self._key != other._key


# Deliberately not anchored to the start and end of the string, to make it
# easier for 3rd party code to reuse
_VERSION_PATTERN = r"""
    v?
    (?:
        (?:(?P[0-9]+)!)?                           # epoch
        (?P[0-9]+(?:\.[0-9]+)*)                  # release segment
        (?P
                                          # pre-release
            [-_\.]?
            (?P(a|b|c|rc|alpha|beta|pre|preview))
            [-_\.]?
            (?P[0-9]+)?
        )?
        (?P                                         # post release
            (?:-(?P[0-9]+))
            |
            (?:
                [-_\.]?
                (?Ppost|rev|r)
                [-_\.]?
                (?P[0-9]+)?
            )
        )?
        (?P                                          # dev release
            [-_\.]?
            (?Pdev)
            [-_\.]?
            (?P[0-9]+)?
        )?
    )
    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
"""

VERSION_PATTERN = _VERSION_PATTERN
"""
A string containing the regular expression used to match a valid version.

The pattern is not anchored at either end, and is intended for embedding in larger
expressions (for example, matching a version number as part of a file name). The
regular expression should be compiled with the ``re.VERBOSE`` and ``re.IGNORECASE``
flags set.

:meta hide-value:
"""


class Version(_BaseVersion):
    """This class abstracts handling of a project's versions.

    A :class:`Version` instance is comparison aware and can be compared and
    sorted using the standard Python interfaces.

    >>> v1 = Version("1.0a5")
    >>> v2 = Version("1.0")
    >>> v1
    
    >>> v2
    
    >>> v1 < v2
    True
    >>> v1 == v2
    False
    >>> v1 > v2
    False
    >>> v1 >= v2
    False
    >>> v1 <= v2
    True
    """

    _regex = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.VERBOSE | re.IGNORECASE)
    _key: CmpKey

    def __init__(self, version: str) -> None:
        """Initialize a Version object.

        :param version:
            The string representation of a version which will be parsed and normalized
            before use.
        :raises InvalidVersion:
            If the ``version`` does not conform to PEP 440 in any way then this
            exception will be raised.
        """

        # Validate the version and parse it into pieces
        match = self._regex.search(version)
        if not match:
            raise InvalidVersion(f"Invalid version: '{version}'")

        # Store the parsed out pieces of the version
        self._version = _Version(
            epoch=int(match.group("epoch")) if match.group("epoch") else 0,
            release=tuple(int(i) for i in match.group("release").split(".")),
            pre=_parse_letter_version(match.group("pre_l"), match.group("pre_n")),
            post=_parse_letter_version(
                match.group("post_l"), match.group("post_n1") or match.group("post_n2")
            ),
            dev=_parse_letter_version(match.group("dev_l"), match.group("dev_n")),
            local=_parse_local_version(match.group("local")),
        )

        # Generate a key which will be used for sorting
        self._key = _cmpkey(
            self._version.epoch,
            self._version.release,
            self._version.pre,
            self._version.post,
            self._version.dev,
            self._version.local,
        )

    def __repr__(self) -> str:
        """A representation of the Version that shows all internal state.

        >>> Version('1.0.0')
        
        """
        return f""

    def __str__(self) -> str:
        """A string representation of the version that can be rounded-tripped.

        >>> str(Version("1.0a5"))
        '1.0a5'
        """
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        # Pre-release
        if self.pre is not None:
            parts.append("".join(str(x) for x in self.pre))

        # Post-release
        if self.post is not None:
            parts.append(f".post{self.post}")

        # Development release
        if self.dev is not None:
            parts.append(f".dev{self.dev}")

        # Local version segment
        if self.local is not None:
            parts.append(f"+{self.local}")

        return "".join(parts)

    @property
    def epoch(self) -> int:
        """The epoch of the version.

        >>> Version("2.0.0").epoch
        0
        >>> Version("1!2.0.0").epoch
        1
        """
        _epoch: int = self._version.epoch
        return _epoch

    @property
    def release(self) -> Tuple[int, ...]:
        """The components of the "release" segment of the version.

        >>> Version("1.2.3").release
        (1, 2, 3)
        >>> Version("2.0.0").release
        (2, 0, 0)
        >>> Version("1!2.0.0.post0").release
        (2, 0, 0)

        Includes trailing zeroes but not the epoch or any pre-release / development /
        post-release suffixes.
        """
        _release: Tuple[int, ...] = self._version.release
        return _release

    @property
    def pre(self) -> Optional[Tuple[str, int]]:
        """The pre-release segment of the version.

        >>> print(Version("1.2.3").pre)
        None
        >>> Version("1.2.3a1").pre
        ('a', 1)
        >>> Version("1.2.3b1").pre
        ('b', 1)
        >>> Version("1.2.3rc1").pre
        ('rc', 1)
        """
        _pre: Optional[Tuple[str, int]] = self._version.pre
        return _pre

    @property
    def post(self) -> Optional[int]:
        """The post-release number of the version.

        >>> print(Version("1.2.3").post)
        None
        >>> Version("1.2.3.post1").post
        1
        """
        return self._version.post[1] if self._version.post else None

    @property
    def dev(self) -> Optional[int]:
        """The development number of the version.

        >>> print(Version("1.2.3").dev)
        None
        >>> Version("1.2.3.dev1").dev
        1
        """
        return self._version.dev[1] if self._version.dev else None

    @property
    def local(self) -> Optional[str]:
        """The local version segment of the version.

        >>> print(Version("1.2.3").local)
        None
        >>> Version("1.2.3+abc").local
        'abc'
        """
        if self._version.local:
            return ".".join(str(x) for x in self._version.local)
        else:
            return None

    @property
    def public(self) -> str:
        """The public portion of the version.

        >>> Version("1.2.3").public
        '1.2.3'
        >>> Version("1.2.3+abc").public
        '1.2.3'
        >>> Version("1.2.3+abc.dev1").public
        '1.2.3'
        """
        return str(self).split("+", 1)[0]

    @property
    def base_version(self) -> str:
        """The "base version" of the version.

        >>> Version("1.2.3").base_version
        '1.2.3'
        >>> Version("1.2.3+abc").base_version
        '1.2.3'
        >>> Version("1!1.2.3+abc.dev1").base_version
        '1!1.2.3'

        The "base version" is the public version of the project without any pre or post
        release markers.
        """
        parts = []

        # Epoch
        if self.epoch != 0:
            parts.append(f"{self.epoch}!")

        # Release segment
        parts.append(".".join(str(x) for x in self.release))

        return "".join(parts)

    @property
    def is_prerelease(self) -> bool:
        """Whether this version is a pre-release.

        >>> Version("1.2.3").is_prerelease
        False
        >>> Version("1.2.3a1").is_prerelease
        True
        >>> Version("1.2.3b1").is_prerelease
        True
        >>> Version("1.2.3rc1").is_prerelease
        True
        >>> Version("1.2.3dev1").is_prerelease
        True
        """
        return self.dev is not None or self.pre is not None

    @property
    def is_postrelease(self) -> bool:
        """Whether this version is a post-release.

        >>> Version("1.2.3").is_postrelease
        False
        >>> Version("1.2.3.post1").is_postrelease
        True
        """
        return self.post is not None

    @property
    def is_devrelease(self) -> bool:
        """Whether this version is a development release.

        >>> Version("1.2.3").is_devrelease
        False
        >>> Version("1.2.3.dev1").is_devrelease
        True
        """
        return self.dev is not None

    @property
    def major(self) -> int:
        """The first item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").major
        1
        """
        return self.release[0] if len(self.release) >= 1 else 0

    @property
    def minor(self) -> int:
        """The second item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").minor
        2
        >>> Version("1").minor
        0
        """
        return self.release[1] if len(self.release) >= 2 else 0

    @property
    def micro(self) -> int:
        """The third item of :attr:`release` or ``0`` if unavailable.

        >>> Version("1.2.3").micro
        3
        >>> Version("1").micro
        0
        """
        return self.release[2] if len(self.release) >= 3 else 0


def _parse_letter_version(
    letter: str, number: Union[str, bytes, SupportsInt]
) -> Optional[Tuple[str, int]]:

    if letter:
        # We consider there to be an implicit 0 in a pre-release if there is
        # not a numeral associated with it.
        if number is None:
            number = 0

        # We normalize any letters to their lower case form
        letter = letter.lower()

        # We consider some words to be alternate spellings of other words and
        # in those cases we want to normalize the spellings to our preferred
        # spelling.
        if letter == "alpha":
            letter = "a"
        elif letter == "beta":
            letter = "b"
        elif letter in ["c", "pre", "preview"]:
            letter = "rc"
        elif letter in ["rev", "r"]:
            letter = "post"

        return letter, int(number)
    if not letter and number:
        # We assume if we are given a number, but we are not given a letter
        # then this is using the implicit post release syntax (e.g. 1.0-1)
        letter = "post"

        return letter, int(number)

    return None


_local_version_separators = re.compile(r"[\._-]")


def _parse_local_version(local: str) -> Optional[LocalType]:
    """
    Takes a string like abc.1.twelve and turns it into ("abc", 1, "twelve").
    """
    if local is not None:
        return tuple(
            part.lower() if not part.isdigit() else int(part)
            for part in _local_version_separators.split(local)
        )
    return None


def _cmpkey(
    epoch: int,
    release: Tuple[int, ...],
    pre: Optional[Tuple[str, int]],
    post: Optional[Tuple[str, int]],
    dev: Optional[Tuple[str, int]],
    local: Optional[Tuple[SubLocalType]],
) -> CmpKey:

    # When we compare a release version, we want to compare it with all of the
    # trailing zeros removed. So we'll use a reverse the list, drop all the now
    # leading zeros until we come to something non zero, then take the rest
    # re-reverse it back into the correct order and make it a tuple and use
    # that for our sorting key.
    _release = tuple(
        reversed(list(itertools.dropwhile(lambda x: x == 0, reversed(release))))
    )

    # We need to "trick" the sorting algorithm to put 1.0.dev0 before 1.0a0.
    # We'll do this by abusing the pre segment, but we _only_ want to do this
    # if there is not a pre or a post segment. If we have one of those then
    # the normal sorting rules will handle this case correctly.
    if pre is None and post is None and dev is not None:
        _pre: PrePostDevType = NegativeInfinity
    # Versions without a pre-release (except as noted above) should sort after
    # those with one.
    elif pre is None:
        _pre = Infinity
    else:
        _pre = pre

    # Versions without a post segment should sort before those with one.
    if post is None:
        _post: PrePostDevType = NegativeInfinity

    else:
        _post = post

    # Versions without a development segment should sort after those with one.
    if dev is None:
        _dev: PrePostDevType = Infinity

    else:
        _dev = dev

    if local is None:
        # Versions without a local segment should sort before those with one.
        _local: LocalType = NegativeInfinity
    else:
        # Versions with a local segment need that segment parsed to implement
        # the sorting rules in PEP440.
        # - Alpha numeric segments sort before numeric segments
        # - Alpha numeric segments sort lexicographically
        # - Numeric segments sort numerically
        # - Shorter versions sort before longer versions when the prefixes
        #   match exactly
        _local = tuple(
            (i, "") if isinstance(i, int) else (NegativeInfinity, i) for i in local
        )

    return epoch, _release, _pre, _post, _dev, _local
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/tomli/0000755000175100001730000000000014467657444020460 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/tomli/__init__.py0000644000175100001730000000061414467657412022565 0ustar00runnerdocker# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
# Licensed to PSF under a Contributor Agreement.

__all__ = ("loads", "load", "TOMLDecodeError")
__version__ = "2.0.1"  # DO NOT EDIT THIS LINE MANUALLY. LET bump2version UTILITY DO IT

from ._parser import TOMLDecodeError, load, loads

# Pretend this exception was created here.
TOMLDecodeError.__module__ = __name__
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/tomli/_parser.py0000644000175100001730000005415114467657412022466 0ustar00runnerdocker# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
# Licensed to PSF under a Contributor Agreement.

from __future__ import annotations

from collections.abc import Iterable
import string
from types import MappingProxyType
from typing import Any, BinaryIO, NamedTuple

from ._re import (
    RE_DATETIME,
    RE_LOCALTIME,
    RE_NUMBER,
    match_to_datetime,
    match_to_localtime,
    match_to_number,
)
from ._types import Key, ParseFloat, Pos

ASCII_CTRL = frozenset(chr(i) for i in range(32)) | frozenset(chr(127))

# Neither of these sets include quotation mark or backslash. They are
# currently handled as separate cases in the parser functions.
ILLEGAL_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t")
ILLEGAL_MULTILINE_BASIC_STR_CHARS = ASCII_CTRL - frozenset("\t\n")

ILLEGAL_LITERAL_STR_CHARS = ILLEGAL_BASIC_STR_CHARS
ILLEGAL_MULTILINE_LITERAL_STR_CHARS = ILLEGAL_MULTILINE_BASIC_STR_CHARS

ILLEGAL_COMMENT_CHARS = ILLEGAL_BASIC_STR_CHARS

TOML_WS = frozenset(" \t")
TOML_WS_AND_NEWLINE = TOML_WS | frozenset("\n")
BARE_KEY_CHARS = frozenset(string.ascii_letters + string.digits + "-_")
KEY_INITIAL_CHARS = BARE_KEY_CHARS | frozenset("\"'")
HEXDIGIT_CHARS = frozenset(string.hexdigits)

BASIC_STR_ESCAPE_REPLACEMENTS = MappingProxyType(
    {
        "\\b": "\u0008",  # backspace
        "\\t": "\u0009",  # tab
        "\\n": "\u000A",  # linefeed
        "\\f": "\u000C",  # form feed
        "\\r": "\u000D",  # carriage return
        '\\"': "\u0022",  # quote
        "\\\\": "\u005C",  # backslash
    }
)


class TOMLDecodeError(ValueError):
    """An error raised if a document is not valid TOML."""


def load(__fp: BinaryIO, *, parse_float: ParseFloat = float) -> dict[str, Any]:
    """Parse TOML from a binary file object."""
    b = __fp.read()
    try:
        s = b.decode()
    except AttributeError:
        raise TypeError(
            "File must be opened in binary mode, e.g. use `open('foo.toml', 'rb')`"
        ) from None
    return loads(s, parse_float=parse_float)


def loads(__s: str, *, parse_float: ParseFloat = float) -> dict[str, Any]:  # noqa: C901
    """Parse TOML from a string."""

    # The spec allows converting "\r\n" to "\n", even in string
    # literals. Let's do so to simplify parsing.
    src = __s.replace("\r\n", "\n")
    pos = 0
    out = Output(NestedDict(), Flags())
    header: Key = ()
    parse_float = make_safe_parse_float(parse_float)

    # Parse one statement at a time
    # (typically means one line in TOML source)
    while True:
        # 1. Skip line leading whitespace
        pos = skip_chars(src, pos, TOML_WS)

        # 2. Parse rules. Expect one of the following:
        #    - end of file
        #    - end of line
        #    - comment
        #    - key/value pair
        #    - append dict to list (and move to its namespace)
        #    - create dict (and move to its namespace)
        # Skip trailing whitespace when applicable.
        try:
            char = src[pos]
        except IndexError:
            break
        if char == "\n":
            pos += 1
            continue
        if char in KEY_INITIAL_CHARS:
            pos = key_value_rule(src, pos, out, header, parse_float)
            pos = skip_chars(src, pos, TOML_WS)
        elif char == "[":
            try:
                second_char: str | None = src[pos + 1]
            except IndexError:
                second_char = None
            out.flags.finalize_pending()
            if second_char == "[":
                pos, header = create_list_rule(src, pos, out)
            else:
                pos, header = create_dict_rule(src, pos, out)
            pos = skip_chars(src, pos, TOML_WS)
        elif char != "#":
            raise suffixed_err(src, pos, "Invalid statement")

        # 3. Skip comment
        pos = skip_comment(src, pos)

        # 4. Expect end of line or end of file
        try:
            char = src[pos]
        except IndexError:
            break
        if char != "\n":
            raise suffixed_err(
                src, pos, "Expected newline or end of document after a statement"
            )
        pos += 1

    return out.data.dict


class Flags:
    """Flags that map to parsed keys/namespaces."""

    # Marks an immutable namespace (inline array or inline table).
    FROZEN = 0
    # Marks a nest that has been explicitly created and can no longer
    # be opened using the "[table]" syntax.
    EXPLICIT_NEST = 1

    def __init__(self) -> None:
        self._flags: dict[str, dict] = {}
        self._pending_flags: set[tuple[Key, int]] = set()

    def add_pending(self, key: Key, flag: int) -> None:
        self._pending_flags.add((key, flag))

    def finalize_pending(self) -> None:
        for key, flag in self._pending_flags:
            self.set(key, flag, recursive=False)
        self._pending_flags.clear()

    def unset_all(self, key: Key) -> None:
        cont = self._flags
        for k in key[:-1]:
            if k not in cont:
                return
            cont = cont[k]["nested"]
        cont.pop(key[-1], None)

    def set(self, key: Key, flag: int, *, recursive: bool) -> None:  # noqa: A003
        cont = self._flags
        key_parent, key_stem = key[:-1], key[-1]
        for k in key_parent:
            if k not in cont:
                cont[k] = {"flags": set(), "recursive_flags": set(), "nested": {}}
            cont = cont[k]["nested"]
        if key_stem not in cont:
            cont[key_stem] = {"flags": set(), "recursive_flags": set(), "nested": {}}
        cont[key_stem]["recursive_flags" if recursive else "flags"].add(flag)

    def is_(self, key: Key, flag: int) -> bool:
        if not key:
            return False  # document root has no flags
        cont = self._flags
        for k in key[:-1]:
            if k not in cont:
                return False
            inner_cont = cont[k]
            if flag in inner_cont["recursive_flags"]:
                return True
            cont = inner_cont["nested"]
        key_stem = key[-1]
        if key_stem in cont:
            cont = cont[key_stem]
            return flag in cont["flags"] or flag in cont["recursive_flags"]
        return False


class NestedDict:
    def __init__(self) -> None:
        # The parsed content of the TOML document
        self.dict: dict[str, Any] = {}

    def get_or_create_nest(
        self,
        key: Key,
        *,
        access_lists: bool = True,
    ) -> dict:
        cont: Any = self.dict
        for k in key:
            if k not in cont:
                cont[k] = {}
            cont = cont[k]
            if access_lists and isinstance(cont, list):
                cont = cont[-1]
            if not isinstance(cont, dict):
                raise KeyError("There is no nest behind this key")
        return cont

    def append_nest_to_list(self, key: Key) -> None:
        cont = self.get_or_create_nest(key[:-1])
        last_key = key[-1]
        if last_key in cont:
            list_ = cont[last_key]
            if not isinstance(list_, list):
                raise KeyError("An object other than list found behind this key")
            list_.append({})
        else:
            cont[last_key] = [{}]


class Output(NamedTuple):
    data: NestedDict
    flags: Flags


def skip_chars(src: str, pos: Pos, chars: Iterable[str]) -> Pos:
    try:
        while src[pos] in chars:
            pos += 1
    except IndexError:
        pass
    return pos


def skip_until(
    src: str,
    pos: Pos,
    expect: str,
    *,
    error_on: frozenset[str],
    error_on_eof: bool,
) -> Pos:
    try:
        new_pos = src.index(expect, pos)
    except ValueError:
        new_pos = len(src)
        if error_on_eof:
            raise suffixed_err(src, new_pos, f"Expected {expect!r}") from None

    if not error_on.isdisjoint(src[pos:new_pos]):
        while src[pos] not in error_on:
            pos += 1
        raise suffixed_err(src, pos, f"Found invalid character {src[pos]!r}")
    return new_pos


def skip_comment(src: str, pos: Pos) -> Pos:
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None
    if char == "#":
        return skip_until(
            src, pos + 1, "\n", error_on=ILLEGAL_COMMENT_CHARS, error_on_eof=False
        )
    return pos


def skip_comments_and_array_ws(src: str, pos: Pos) -> Pos:
    while True:
        pos_before_skip = pos
        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
        pos = skip_comment(src, pos)
        if pos == pos_before_skip:
            return pos


def create_dict_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
    pos += 1  # Skip "["
    pos = skip_chars(src, pos, TOML_WS)
    pos, key = parse_key(src, pos)

    if out.flags.is_(key, Flags.EXPLICIT_NEST) or out.flags.is_(key, Flags.FROZEN):
        raise suffixed_err(src, pos, f"Cannot declare {key} twice")
    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
    try:
        out.data.get_or_create_nest(key)
    except KeyError:
        raise suffixed_err(src, pos, "Cannot overwrite a value") from None

    if not src.startswith("]", pos):
        raise suffixed_err(src, pos, "Expected ']' at the end of a table declaration")
    return pos + 1, key


def create_list_rule(src: str, pos: Pos, out: Output) -> tuple[Pos, Key]:
    pos += 2  # Skip "[["
    pos = skip_chars(src, pos, TOML_WS)
    pos, key = parse_key(src, pos)

    if out.flags.is_(key, Flags.FROZEN):
        raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
    # Free the namespace now that it points to another empty list item...
    out.flags.unset_all(key)
    # ...but this key precisely is still prohibited from table declaration
    out.flags.set(key, Flags.EXPLICIT_NEST, recursive=False)
    try:
        out.data.append_nest_to_list(key)
    except KeyError:
        raise suffixed_err(src, pos, "Cannot overwrite a value") from None

    if not src.startswith("]]", pos):
        raise suffixed_err(src, pos, "Expected ']]' at the end of an array declaration")
    return pos + 2, key


def key_value_rule(
    src: str, pos: Pos, out: Output, header: Key, parse_float: ParseFloat
) -> Pos:
    pos, key, value = parse_key_value_pair(src, pos, parse_float)
    key_parent, key_stem = key[:-1], key[-1]
    abs_key_parent = header + key_parent

    relative_path_cont_keys = (header + key[:i] for i in range(1, len(key)))
    for cont_key in relative_path_cont_keys:
        # Check that dotted key syntax does not redefine an existing table
        if out.flags.is_(cont_key, Flags.EXPLICIT_NEST):
            raise suffixed_err(src, pos, f"Cannot redefine namespace {cont_key}")
        # Containers in the relative path can't be opened with the table syntax or
        # dotted key/value syntax in following table sections.
        out.flags.add_pending(cont_key, Flags.EXPLICIT_NEST)

    if out.flags.is_(abs_key_parent, Flags.FROZEN):
        raise suffixed_err(
            src, pos, f"Cannot mutate immutable namespace {abs_key_parent}"
        )

    try:
        nest = out.data.get_or_create_nest(abs_key_parent)
    except KeyError:
        raise suffixed_err(src, pos, "Cannot overwrite a value") from None
    if key_stem in nest:
        raise suffixed_err(src, pos, "Cannot overwrite a value")
    # Mark inline table and array namespaces recursively immutable
    if isinstance(value, (dict, list)):
        out.flags.set(header + key, Flags.FROZEN, recursive=True)
    nest[key_stem] = value
    return pos


def parse_key_value_pair(
    src: str, pos: Pos, parse_float: ParseFloat
) -> tuple[Pos, Key, Any]:
    pos, key = parse_key(src, pos)
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None
    if char != "=":
        raise suffixed_err(src, pos, "Expected '=' after a key in a key/value pair")
    pos += 1
    pos = skip_chars(src, pos, TOML_WS)
    pos, value = parse_value(src, pos, parse_float)
    return pos, key, value


def parse_key(src: str, pos: Pos) -> tuple[Pos, Key]:
    pos, key_part = parse_key_part(src, pos)
    key: Key = (key_part,)
    pos = skip_chars(src, pos, TOML_WS)
    while True:
        try:
            char: str | None = src[pos]
        except IndexError:
            char = None
        if char != ".":
            return pos, key
        pos += 1
        pos = skip_chars(src, pos, TOML_WS)
        pos, key_part = parse_key_part(src, pos)
        key += (key_part,)
        pos = skip_chars(src, pos, TOML_WS)


def parse_key_part(src: str, pos: Pos) -> tuple[Pos, str]:
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None
    if char in BARE_KEY_CHARS:
        start_pos = pos
        pos = skip_chars(src, pos, BARE_KEY_CHARS)
        return pos, src[start_pos:pos]
    if char == "'":
        return parse_literal_str(src, pos)
    if char == '"':
        return parse_one_line_basic_str(src, pos)
    raise suffixed_err(src, pos, "Invalid initial character for a key part")


def parse_one_line_basic_str(src: str, pos: Pos) -> tuple[Pos, str]:
    pos += 1
    return parse_basic_str(src, pos, multiline=False)


def parse_array(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, list]:
    pos += 1
    array: list = []

    pos = skip_comments_and_array_ws(src, pos)
    if src.startswith("]", pos):
        return pos + 1, array
    while True:
        pos, val = parse_value(src, pos, parse_float)
        array.append(val)
        pos = skip_comments_and_array_ws(src, pos)

        c = src[pos : pos + 1]
        if c == "]":
            return pos + 1, array
        if c != ",":
            raise suffixed_err(src, pos, "Unclosed array")
        pos += 1

        pos = skip_comments_and_array_ws(src, pos)
        if src.startswith("]", pos):
            return pos + 1, array


def parse_inline_table(src: str, pos: Pos, parse_float: ParseFloat) -> tuple[Pos, dict]:
    pos += 1
    nested_dict = NestedDict()
    flags = Flags()

    pos = skip_chars(src, pos, TOML_WS)
    if src.startswith("}", pos):
        return pos + 1, nested_dict.dict
    while True:
        pos, key, value = parse_key_value_pair(src, pos, parse_float)
        key_parent, key_stem = key[:-1], key[-1]
        if flags.is_(key, Flags.FROZEN):
            raise suffixed_err(src, pos, f"Cannot mutate immutable namespace {key}")
        try:
            nest = nested_dict.get_or_create_nest(key_parent, access_lists=False)
        except KeyError:
            raise suffixed_err(src, pos, "Cannot overwrite a value") from None
        if key_stem in nest:
            raise suffixed_err(src, pos, f"Duplicate inline table key {key_stem!r}")
        nest[key_stem] = value
        pos = skip_chars(src, pos, TOML_WS)
        c = src[pos : pos + 1]
        if c == "}":
            return pos + 1, nested_dict.dict
        if c != ",":
            raise suffixed_err(src, pos, "Unclosed inline table")
        if isinstance(value, (dict, list)):
            flags.set(key, Flags.FROZEN, recursive=True)
        pos += 1
        pos = skip_chars(src, pos, TOML_WS)


def parse_basic_str_escape(
    src: str, pos: Pos, *, multiline: bool = False
) -> tuple[Pos, str]:
    escape_id = src[pos : pos + 2]
    pos += 2
    if multiline and escape_id in {"\\ ", "\\\t", "\\\n"}:
        # Skip whitespace until next non-whitespace character or end of
        # the doc. Error if non-whitespace is found before newline.
        if escape_id != "\\\n":
            pos = skip_chars(src, pos, TOML_WS)
            try:
                char = src[pos]
            except IndexError:
                return pos, ""
            if char != "\n":
                raise suffixed_err(src, pos, "Unescaped '\\' in a string")
            pos += 1
        pos = skip_chars(src, pos, TOML_WS_AND_NEWLINE)
        return pos, ""
    if escape_id == "\\u":
        return parse_hex_char(src, pos, 4)
    if escape_id == "\\U":
        return parse_hex_char(src, pos, 8)
    try:
        return pos, BASIC_STR_ESCAPE_REPLACEMENTS[escape_id]
    except KeyError:
        raise suffixed_err(src, pos, "Unescaped '\\' in a string") from None


def parse_basic_str_escape_multiline(src: str, pos: Pos) -> tuple[Pos, str]:
    return parse_basic_str_escape(src, pos, multiline=True)


def parse_hex_char(src: str, pos: Pos, hex_len: int) -> tuple[Pos, str]:
    hex_str = src[pos : pos + hex_len]
    if len(hex_str) != hex_len or not HEXDIGIT_CHARS.issuperset(hex_str):
        raise suffixed_err(src, pos, "Invalid hex value")
    pos += hex_len
    hex_int = int(hex_str, 16)
    if not is_unicode_scalar_value(hex_int):
        raise suffixed_err(src, pos, "Escaped character is not a Unicode scalar value")
    return pos, chr(hex_int)


def parse_literal_str(src: str, pos: Pos) -> tuple[Pos, str]:
    pos += 1  # Skip starting apostrophe
    start_pos = pos
    pos = skip_until(
        src, pos, "'", error_on=ILLEGAL_LITERAL_STR_CHARS, error_on_eof=True
    )
    return pos + 1, src[start_pos:pos]  # Skip ending apostrophe


def parse_multiline_str(src: str, pos: Pos, *, literal: bool) -> tuple[Pos, str]:
    pos += 3
    if src.startswith("\n", pos):
        pos += 1

    if literal:
        delim = "'"
        end_pos = skip_until(
            src,
            pos,
            "'''",
            error_on=ILLEGAL_MULTILINE_LITERAL_STR_CHARS,
            error_on_eof=True,
        )
        result = src[pos:end_pos]
        pos = end_pos + 3
    else:
        delim = '"'
        pos, result = parse_basic_str(src, pos, multiline=True)

    # Add at maximum two extra apostrophes/quotes if the end sequence
    # is 4 or 5 chars long instead of just 3.
    if not src.startswith(delim, pos):
        return pos, result
    pos += 1
    if not src.startswith(delim, pos):
        return pos, result + delim
    pos += 1
    return pos, result + (delim * 2)


def parse_basic_str(src: str, pos: Pos, *, multiline: bool) -> tuple[Pos, str]:
    if multiline:
        error_on = ILLEGAL_MULTILINE_BASIC_STR_CHARS
        parse_escapes = parse_basic_str_escape_multiline
    else:
        error_on = ILLEGAL_BASIC_STR_CHARS
        parse_escapes = parse_basic_str_escape
    result = ""
    start_pos = pos
    while True:
        try:
            char = src[pos]
        except IndexError:
            raise suffixed_err(src, pos, "Unterminated string") from None
        if char == '"':
            if not multiline:
                return pos + 1, result + src[start_pos:pos]
            if src.startswith('"""', pos):
                return pos + 3, result + src[start_pos:pos]
            pos += 1
            continue
        if char == "\\":
            result += src[start_pos:pos]
            pos, parsed_escape = parse_escapes(src, pos)
            result += parsed_escape
            start_pos = pos
            continue
        if char in error_on:
            raise suffixed_err(src, pos, f"Illegal character {char!r}")
        pos += 1


def parse_value(  # noqa: C901
    src: str, pos: Pos, parse_float: ParseFloat
) -> tuple[Pos, Any]:
    try:
        char: str | None = src[pos]
    except IndexError:
        char = None

    # IMPORTANT: order conditions based on speed of checking and likelihood

    # Basic strings
    if char == '"':
        if src.startswith('"""', pos):
            return parse_multiline_str(src, pos, literal=False)
        return parse_one_line_basic_str(src, pos)

    # Literal strings
    if char == "'":
        if src.startswith("'''", pos):
            return parse_multiline_str(src, pos, literal=True)
        return parse_literal_str(src, pos)

    # Booleans
    if char == "t":
        if src.startswith("true", pos):
            return pos + 4, True
    if char == "f":
        if src.startswith("false", pos):
            return pos + 5, False

    # Arrays
    if char == "[":
        return parse_array(src, pos, parse_float)

    # Inline tables
    if char == "{":
        return parse_inline_table(src, pos, parse_float)

    # Dates and times
    datetime_match = RE_DATETIME.match(src, pos)
    if datetime_match:
        try:
            datetime_obj = match_to_datetime(datetime_match)
        except ValueError as e:
            raise suffixed_err(src, pos, "Invalid date or datetime") from e
        return datetime_match.end(), datetime_obj
    localtime_match = RE_LOCALTIME.match(src, pos)
    if localtime_match:
        return localtime_match.end(), match_to_localtime(localtime_match)

    # Integers and "normal" floats.
    # The regex will greedily match any type starting with a decimal
    # char, so needs to be located after handling of dates and times.
    number_match = RE_NUMBER.match(src, pos)
    if number_match:
        return number_match.end(), match_to_number(number_match, parse_float)

    # Special floats
    first_three = src[pos : pos + 3]
    if first_three in {"inf", "nan"}:
        return pos + 3, parse_float(first_three)
    first_four = src[pos : pos + 4]
    if first_four in {"-inf", "+inf", "-nan", "+nan"}:
        return pos + 4, parse_float(first_four)

    raise suffixed_err(src, pos, "Invalid value")


def suffixed_err(src: str, pos: Pos, msg: str) -> TOMLDecodeError:
    """Return a `TOMLDecodeError` where error message is suffixed with
    coordinates in source."""

    def coord_repr(src: str, pos: Pos) -> str:
        if pos >= len(src):
            return "end of document"
        line = src.count("\n", 0, pos) + 1
        if line == 1:
            column = pos + 1
        else:
            column = pos - src.rindex("\n", 0, pos)
        return f"line {line}, column {column}"

    return TOMLDecodeError(f"{msg} (at {coord_repr(src, pos)})")


def is_unicode_scalar_value(codepoint: int) -> bool:
    return (0 <= codepoint <= 55295) or (57344 <= codepoint <= 1114111)


def make_safe_parse_float(parse_float: ParseFloat) -> ParseFloat:
    """A decorator to make `parse_float` safe.

    `parse_float` must not return dicts or lists, because these types
    would be mixed with parsed TOML tables and arrays, thus confusing
    the parser. The returned decorated callable raises `ValueError`
    instead of returning illegal types.
    """
    # The default `float` callable never returns illegal types. Optimize it.
    if parse_float is float:  # type: ignore[comparison-overlap]
        return float

    def safe_parse_float(float_str: str) -> Any:
        float_value = parse_float(float_str)
        if isinstance(float_value, (dict, list)):
            raise ValueError("parse_float must not return dicts or lists")
        return float_value

    return safe_parse_float
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/tomli/_re.py0000644000175100001730000000557714467657412021610 0ustar00runnerdocker# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
# Licensed to PSF under a Contributor Agreement.

from __future__ import annotations

from datetime import date, datetime, time, timedelta, timezone, tzinfo
from functools import lru_cache
import re
from typing import Any

from ._types import ParseFloat

# E.g.
# - 00:32:00.999999
# - 00:32:00
_TIME_RE_STR = r"([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(?:\.([0-9]{1,6})[0-9]*)?"

RE_NUMBER = re.compile(
    r"""
0
(?:
    x[0-9A-Fa-f](?:_?[0-9A-Fa-f])*   # hex
    |
    b[01](?:_?[01])*                 # bin
    |
    o[0-7](?:_?[0-7])*               # oct
)
|
[+-]?(?:0|[1-9](?:_?[0-9])*)         # dec, integer part
(?P
    (?:\.[0-9](?:_?[0-9])*)?         # optional fractional part
    (?:[eE][+-]?[0-9](?:_?[0-9])*)?  # optional exponent part
)
""",
    flags=re.VERBOSE,
)
RE_LOCALTIME = re.compile(_TIME_RE_STR)
RE_DATETIME = re.compile(
    rf"""
([0-9]{{4}})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])  # date, e.g. 1988-10-27
(?:
    [Tt ]
    {_TIME_RE_STR}
    (?:([Zz])|([+-])([01][0-9]|2[0-3]):([0-5][0-9]))?  # optional time offset
)?
""",
    flags=re.VERBOSE,
)


def match_to_datetime(match: re.Match) -> datetime | date:
    """Convert a `RE_DATETIME` match to `datetime.datetime` or `datetime.date`.

    Raises ValueError if the match does not correspond to a valid date
    or datetime.
    """
    (
        year_str,
        month_str,
        day_str,
        hour_str,
        minute_str,
        sec_str,
        micros_str,
        zulu_time,
        offset_sign_str,
        offset_hour_str,
        offset_minute_str,
    ) = match.groups()
    year, month, day = int(year_str), int(month_str), int(day_str)
    if hour_str is None:
        return date(year, month, day)
    hour, minute, sec = int(hour_str), int(minute_str), int(sec_str)
    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
    if offset_sign_str:
        tz: tzinfo | None = cached_tz(
            offset_hour_str, offset_minute_str, offset_sign_str
        )
    elif zulu_time:
        tz = timezone.utc
    else:  # local date-time
        tz = None
    return datetime(year, month, day, hour, minute, sec, micros, tzinfo=tz)


@lru_cache(maxsize=None)
def cached_tz(hour_str: str, minute_str: str, sign_str: str) -> timezone:
    sign = 1 if sign_str == "+" else -1
    return timezone(
        timedelta(
            hours=sign * int(hour_str),
            minutes=sign * int(minute_str),
        )
    )


def match_to_localtime(match: re.Match) -> time:
    hour_str, minute_str, sec_str, micros_str = match.groups()
    micros = int(micros_str.ljust(6, "0")) if micros_str else 0
    return time(int(hour_str), int(minute_str), int(sec_str), micros)


def match_to_number(match: re.Match, parse_float: ParseFloat) -> Any:
    if match.group("floatpart"):
        return parse_float(match.group())
    return int(match.group(), 0)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/tomli/_types.py0000644000175100001730000000037614467657412022336 0ustar00runnerdocker# SPDX-License-Identifier: MIT
# SPDX-FileCopyrightText: 2021 Taneli Hukkinen
# Licensed to PSF under a Contributor Agreement.

from typing import Any, Callable, Tuple

# Type annotations
ParseFloat = Callable[[str], Any]
Key = Tuple[str, ...]
Pos = int
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/typing_extensions.py0000644000175100001730000025215514467657412023504 0ustar00runnerdockerimport abc
import collections
import collections.abc
import operator
import sys
import typing

# After PEP 560, internal typing API was substantially reworked.
# This is especially important for Protocol class which uses internal APIs
# quite extensively.
PEP_560 = sys.version_info[:3] >= (3, 7, 0)

if PEP_560:
    GenericMeta = type
else:
    # 3.6
    from typing import GenericMeta, _type_vars  # noqa

# The two functions below are copies of typing internal helpers.
# They are needed by _ProtocolMeta


def _no_slots_copy(dct):
    dict_copy = dict(dct)
    if '__slots__' in dict_copy:
        for slot in dict_copy['__slots__']:
            dict_copy.pop(slot, None)
    return dict_copy


def _check_generic(cls, parameters):
    if not cls.__parameters__:
        raise TypeError(f"{cls} is not a generic class")
    alen = len(parameters)
    elen = len(cls.__parameters__)
    if alen != elen:
        raise TypeError(f"Too {'many' if alen > elen else 'few'} arguments for {cls};"
                        f" actual {alen}, expected {elen}")


# Please keep __all__ alphabetized within each category.
__all__ = [
    # Super-special typing primitives.
    'ClassVar',
    'Concatenate',
    'Final',
    'ParamSpec',
    'Self',
    'Type',

    # ABCs (from collections.abc).
    'Awaitable',
    'AsyncIterator',
    'AsyncIterable',
    'Coroutine',
    'AsyncGenerator',
    'AsyncContextManager',
    'ChainMap',

    # Concrete collection types.
    'ContextManager',
    'Counter',
    'Deque',
    'DefaultDict',
    'OrderedDict',
    'TypedDict',

    # Structural checks, a.k.a. protocols.
    'SupportsIndex',

    # One-off things.
    'Annotated',
    'final',
    'IntVar',
    'Literal',
    'NewType',
    'overload',
    'Protocol',
    'runtime',
    'runtime_checkable',
    'Text',
    'TypeAlias',
    'TypeGuard',
    'TYPE_CHECKING',
]

if PEP_560:
    __all__.extend(["get_args", "get_origin", "get_type_hints"])

# 3.6.2+
if hasattr(typing, 'NoReturn'):
    NoReturn = typing.NoReturn
# 3.6.0-3.6.1
else:
    class _NoReturn(typing._FinalTypingBase, _root=True):
        """Special type indicating functions that never return.
        Example::

          from typing import NoReturn

          def stop() -> NoReturn:
              raise Exception('no way')

        This type is invalid in other positions, e.g., ``List[NoReturn]``
        will fail in static type checkers.
        """
        __slots__ = ()

        def __instancecheck__(self, obj):
            raise TypeError("NoReturn cannot be used with isinstance().")

        def __subclasscheck__(self, cls):
            raise TypeError("NoReturn cannot be used with issubclass().")

    NoReturn = _NoReturn(_root=True)

# Some unconstrained type variables.  These are used by the container types.
# (These are not for export.)
T = typing.TypeVar('T')  # Any type.
KT = typing.TypeVar('KT')  # Key type.
VT = typing.TypeVar('VT')  # Value type.
T_co = typing.TypeVar('T_co', covariant=True)  # Any type covariant containers.
T_contra = typing.TypeVar('T_contra', contravariant=True)  # Ditto contravariant.

ClassVar = typing.ClassVar

# On older versions of typing there is an internal class named "Final".
# 3.8+
if hasattr(typing, 'Final') and sys.version_info[:2] >= (3, 7):
    Final = typing.Final
# 3.7
elif sys.version_info[:2] >= (3, 7):
    class _FinalForm(typing._SpecialForm, _root=True):

        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            item = typing._type_check(parameters,
                                      f'{self._name} accepts only single type')
            return typing._GenericAlias(self, (item,))

    Final = _FinalForm('Final',
                       doc="""A special typing construct to indicate that a name
                       cannot be re-assigned or overridden in a subclass.
                       For example:

                           MAX_SIZE: Final = 9000
                           MAX_SIZE += 1  # Error reported by type checker

                           class Connection:
                               TIMEOUT: Final[int] = 10
                           class FastConnector(Connection):
                               TIMEOUT = 1  # Error reported by type checker

                       There is no runtime checking of these properties.""")
# 3.6
else:
    class _Final(typing._FinalTypingBase, _root=True):
        """A special typing construct to indicate that a name
        cannot be re-assigned or overridden in a subclass.
        For example:

            MAX_SIZE: Final = 9000
            MAX_SIZE += 1  # Error reported by type checker

            class Connection:
                TIMEOUT: Final[int] = 10
            class FastConnector(Connection):
                TIMEOUT = 1  # Error reported by type checker

        There is no runtime checking of these properties.
        """

        __slots__ = ('__type__',)

        def __init__(self, tp=None, **kwds):
            self.__type__ = tp

        def __getitem__(self, item):
            cls = type(self)
            if self.__type__ is None:
                return cls(typing._type_check(item,
                           f'{cls.__name__[1:]} accepts only single type.'),
                           _root=True)
            raise TypeError(f'{cls.__name__[1:]} cannot be further subscripted')

        def _eval_type(self, globalns, localns):
            new_tp = typing._eval_type(self.__type__, globalns, localns)
            if new_tp == self.__type__:
                return self
            return type(self)(new_tp, _root=True)

        def __repr__(self):
            r = super().__repr__()
            if self.__type__ is not None:
                r += f'[{typing._type_repr(self.__type__)}]'
            return r

        def __hash__(self):
            return hash((type(self).__name__, self.__type__))

        def __eq__(self, other):
            if not isinstance(other, _Final):
                return NotImplemented
            if self.__type__ is not None:
                return self.__type__ == other.__type__
            return self is other

    Final = _Final(_root=True)


# 3.8+
if hasattr(typing, 'final'):
    final = typing.final
# 3.6-3.7
else:
    def final(f):
        """This decorator can be used to indicate to type checkers that
        the decorated method cannot be overridden, and decorated class
        cannot be subclassed. For example:

            class Base:
                @final
                def done(self) -> None:
                    ...
            class Sub(Base):
                def done(self) -> None:  # Error reported by type checker
                    ...
            @final
            class Leaf:
                ...
            class Other(Leaf):  # Error reported by type checker
                ...

        There is no runtime checking of these properties.
        """
        return f


def IntVar(name):
    return typing.TypeVar(name)


# 3.8+:
if hasattr(typing, 'Literal'):
    Literal = typing.Literal
# 3.7:
elif sys.version_info[:2] >= (3, 7):
    class _LiteralForm(typing._SpecialForm, _root=True):

        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            return typing._GenericAlias(self, parameters)

    Literal = _LiteralForm('Literal',
                           doc="""A type that can be used to indicate to type checkers
                           that the corresponding value has a value literally equivalent
                           to the provided parameter. For example:

                               var: Literal[4] = 4

                           The type checker understands that 'var' is literally equal to
                           the value 4 and no other value.

                           Literal[...] cannot be subclassed. There is no runtime
                           checking verifying that the parameter is actually a value
                           instead of a type.""")
# 3.6:
else:
    class _Literal(typing._FinalTypingBase, _root=True):
        """A type that can be used to indicate to type checkers that the
        corresponding value has a value literally equivalent to the
        provided parameter. For example:

            var: Literal[4] = 4

        The type checker understands that 'var' is literally equal to the
        value 4 and no other value.

        Literal[...] cannot be subclassed. There is no runtime checking
        verifying that the parameter is actually a value instead of a type.
        """

        __slots__ = ('__values__',)

        def __init__(self, values=None, **kwds):
            self.__values__ = values

        def __getitem__(self, values):
            cls = type(self)
            if self.__values__ is None:
                if not isinstance(values, tuple):
                    values = (values,)
                return cls(values, _root=True)
            raise TypeError(f'{cls.__name__[1:]} cannot be further subscripted')

        def _eval_type(self, globalns, localns):
            return self

        def __repr__(self):
            r = super().__repr__()
            if self.__values__ is not None:
                r += f'[{", ".join(map(typing._type_repr, self.__values__))}]'
            return r

        def __hash__(self):
            return hash((type(self).__name__, self.__values__))

        def __eq__(self, other):
            if not isinstance(other, _Literal):
                return NotImplemented
            if self.__values__ is not None:
                return self.__values__ == other.__values__
            return self is other

    Literal = _Literal(_root=True)


_overload_dummy = typing._overload_dummy  # noqa
overload = typing.overload


# This is not a real generic class.  Don't use outside annotations.
Type = typing.Type

# Various ABCs mimicking those in collections.abc.
# A few are simply re-exported for completeness.


class _ExtensionsGenericMeta(GenericMeta):
    def __subclasscheck__(self, subclass):
        """This mimics a more modern GenericMeta.__subclasscheck__() logic
        (that does not have problems with recursion) to work around interactions
        between collections, typing, and typing_extensions on older
        versions of Python, see https://github.com/python/typing/issues/501.
        """
        if self.__origin__ is not None:
            if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools']:
                raise TypeError("Parameterized generics cannot be used with class "
                                "or instance checks")
            return False
        if not self.__extra__:
            return super().__subclasscheck__(subclass)
        res = self.__extra__.__subclasshook__(subclass)
        if res is not NotImplemented:
            return res
        if self.__extra__ in subclass.__mro__:
            return True
        for scls in self.__extra__.__subclasses__():
            if isinstance(scls, GenericMeta):
                continue
            if issubclass(subclass, scls):
                return True
        return False


Awaitable = typing.Awaitable
Coroutine = typing.Coroutine
AsyncIterable = typing.AsyncIterable
AsyncIterator = typing.AsyncIterator

# 3.6.1+
if hasattr(typing, 'Deque'):
    Deque = typing.Deque
# 3.6.0
else:
    class Deque(collections.deque, typing.MutableSequence[T],
                metaclass=_ExtensionsGenericMeta,
                extra=collections.deque):
        __slots__ = ()

        def __new__(cls, *args, **kwds):
            if cls._gorg is Deque:
                return collections.deque(*args, **kwds)
            return typing._generic_new(collections.deque, cls, *args, **kwds)

ContextManager = typing.ContextManager
# 3.6.2+
if hasattr(typing, 'AsyncContextManager'):
    AsyncContextManager = typing.AsyncContextManager
# 3.6.0-3.6.1
else:
    from _collections_abc import _check_methods as _check_methods_in_mro  # noqa

    class AsyncContextManager(typing.Generic[T_co]):
        __slots__ = ()

        async def __aenter__(self):
            return self

        @abc.abstractmethod
        async def __aexit__(self, exc_type, exc_value, traceback):
            return None

        @classmethod
        def __subclasshook__(cls, C):
            if cls is AsyncContextManager:
                return _check_methods_in_mro(C, "__aenter__", "__aexit__")
            return NotImplemented

DefaultDict = typing.DefaultDict

# 3.7.2+
if hasattr(typing, 'OrderedDict'):
    OrderedDict = typing.OrderedDict
# 3.7.0-3.7.2
elif (3, 7, 0) <= sys.version_info[:3] < (3, 7, 2):
    OrderedDict = typing._alias(collections.OrderedDict, (KT, VT))
# 3.6
else:
    class OrderedDict(collections.OrderedDict, typing.MutableMapping[KT, VT],
                      metaclass=_ExtensionsGenericMeta,
                      extra=collections.OrderedDict):

        __slots__ = ()

        def __new__(cls, *args, **kwds):
            if cls._gorg is OrderedDict:
                return collections.OrderedDict(*args, **kwds)
            return typing._generic_new(collections.OrderedDict, cls, *args, **kwds)

# 3.6.2+
if hasattr(typing, 'Counter'):
    Counter = typing.Counter
# 3.6.0-3.6.1
else:
    class Counter(collections.Counter,
                  typing.Dict[T, int],
                  metaclass=_ExtensionsGenericMeta, extra=collections.Counter):

        __slots__ = ()

        def __new__(cls, *args, **kwds):
            if cls._gorg is Counter:
                return collections.Counter(*args, **kwds)
            return typing._generic_new(collections.Counter, cls, *args, **kwds)

# 3.6.1+
if hasattr(typing, 'ChainMap'):
    ChainMap = typing.ChainMap
elif hasattr(collections, 'ChainMap'):
    class ChainMap(collections.ChainMap, typing.MutableMapping[KT, VT],
                   metaclass=_ExtensionsGenericMeta,
                   extra=collections.ChainMap):

        __slots__ = ()

        def __new__(cls, *args, **kwds):
            if cls._gorg is ChainMap:
                return collections.ChainMap(*args, **kwds)
            return typing._generic_new(collections.ChainMap, cls, *args, **kwds)

# 3.6.1+
if hasattr(typing, 'AsyncGenerator'):
    AsyncGenerator = typing.AsyncGenerator
# 3.6.0
else:
    class AsyncGenerator(AsyncIterator[T_co], typing.Generic[T_co, T_contra],
                         metaclass=_ExtensionsGenericMeta,
                         extra=collections.abc.AsyncGenerator):
        __slots__ = ()

NewType = typing.NewType
Text = typing.Text
TYPE_CHECKING = typing.TYPE_CHECKING


def _gorg(cls):
    """This function exists for compatibility with old typing versions."""
    assert isinstance(cls, GenericMeta)
    if hasattr(cls, '_gorg'):
        return cls._gorg
    while cls.__origin__ is not None:
        cls = cls.__origin__
    return cls


_PROTO_WHITELIST = ['Callable', 'Awaitable',
                    'Iterable', 'Iterator', 'AsyncIterable', 'AsyncIterator',
                    'Hashable', 'Sized', 'Container', 'Collection', 'Reversible',
                    'ContextManager', 'AsyncContextManager']


def _get_protocol_attrs(cls):
    attrs = set()
    for base in cls.__mro__[:-1]:  # without object
        if base.__name__ in ('Protocol', 'Generic'):
            continue
        annotations = getattr(base, '__annotations__', {})
        for attr in list(base.__dict__.keys()) + list(annotations.keys()):
            if (not attr.startswith('_abc_') and attr not in (
                    '__abstractmethods__', '__annotations__', '__weakref__',
                    '_is_protocol', '_is_runtime_protocol', '__dict__',
                    '__args__', '__slots__',
                    '__next_in_mro__', '__parameters__', '__origin__',
                    '__orig_bases__', '__extra__', '__tree_hash__',
                    '__doc__', '__subclasshook__', '__init__', '__new__',
                    '__module__', '_MutableMapping__marker', '_gorg')):
                attrs.add(attr)
    return attrs


def _is_callable_members_only(cls):
    return all(callable(getattr(cls, attr, None)) for attr in _get_protocol_attrs(cls))


# 3.8+
if hasattr(typing, 'Protocol'):
    Protocol = typing.Protocol
# 3.7
elif PEP_560:
    from typing import _collect_type_vars  # noqa

    def _no_init(self, *args, **kwargs):
        if type(self)._is_protocol:
            raise TypeError('Protocols cannot be instantiated')

    class _ProtocolMeta(abc.ABCMeta):
        # This metaclass is a bit unfortunate and exists only because of the lack
        # of __instancehook__.
        def __instancecheck__(cls, instance):
            # We need this method for situations where attributes are
            # assigned in __init__.
            if ((not getattr(cls, '_is_protocol', False) or
                 _is_callable_members_only(cls)) and
                    issubclass(instance.__class__, cls)):
                return True
            if cls._is_protocol:
                if all(hasattr(instance, attr) and
                       (not callable(getattr(cls, attr, None)) or
                        getattr(instance, attr) is not None)
                       for attr in _get_protocol_attrs(cls)):
                    return True
            return super().__instancecheck__(instance)

    class Protocol(metaclass=_ProtocolMeta):
        # There is quite a lot of overlapping code with typing.Generic.
        # Unfortunately it is hard to avoid this while these live in two different
        # modules. The duplicated code will be removed when Protocol is moved to typing.
        """Base class for protocol classes. Protocol classes are defined as::

            class Proto(Protocol):
                def meth(self) -> int:
                    ...

        Such classes are primarily used with static type checkers that recognize
        structural subtyping (static duck-typing), for example::

            class C:
                def meth(self) -> int:
                    return 0

            def func(x: Proto) -> int:
                return x.meth()

            func(C())  # Passes static type check

        See PEP 544 for details. Protocol classes decorated with
        @typing_extensions.runtime act as simple-minded runtime protocol that checks
        only the presence of given attributes, ignoring their type signatures.

        Protocol classes can be generic, they are defined as::

            class GenProto(Protocol[T]):
                def meth(self) -> T:
                    ...
        """
        __slots__ = ()
        _is_protocol = True

        def __new__(cls, *args, **kwds):
            if cls is Protocol:
                raise TypeError("Type Protocol cannot be instantiated; "
                                "it can only be used as a base class")
            return super().__new__(cls)

        @typing._tp_cache
        def __class_getitem__(cls, params):
            if not isinstance(params, tuple):
                params = (params,)
            if not params and cls is not typing.Tuple:
                raise TypeError(
                    f"Parameter list to {cls.__qualname__}[...] cannot be empty")
            msg = "Parameters to generic types must be types."
            params = tuple(typing._type_check(p, msg) for p in params)  # noqa
            if cls is Protocol:
                # Generic can only be subscripted with unique type variables.
                if not all(isinstance(p, typing.TypeVar) for p in params):
                    i = 0
                    while isinstance(params[i], typing.TypeVar):
                        i += 1
                    raise TypeError(
                        "Parameters to Protocol[...] must all be type variables."
                        f" Parameter {i + 1} is {params[i]}")
                if len(set(params)) != len(params):
                    raise TypeError(
                        "Parameters to Protocol[...] must all be unique")
            else:
                # Subscripting a regular Generic subclass.
                _check_generic(cls, params)
            return typing._GenericAlias(cls, params)

        def __init_subclass__(cls, *args, **kwargs):
            tvars = []
            if '__orig_bases__' in cls.__dict__:
                error = typing.Generic in cls.__orig_bases__
            else:
                error = typing.Generic in cls.__bases__
            if error:
                raise TypeError("Cannot inherit from plain Generic")
            if '__orig_bases__' in cls.__dict__:
                tvars = _collect_type_vars(cls.__orig_bases__)
                # Look for Generic[T1, ..., Tn] or Protocol[T1, ..., Tn].
                # If found, tvars must be a subset of it.
                # If not found, tvars is it.
                # Also check for and reject plain Generic,
                # and reject multiple Generic[...] and/or Protocol[...].
                gvars = None
                for base in cls.__orig_bases__:
                    if (isinstance(base, typing._GenericAlias) and
                            base.__origin__ in (typing.Generic, Protocol)):
                        # for error messages
                        the_base = base.__origin__.__name__
                        if gvars is not None:
                            raise TypeError(
                                "Cannot inherit from Generic[...]"
                                " and/or Protocol[...] multiple types.")
                        gvars = base.__parameters__
                if gvars is None:
                    gvars = tvars
                else:
                    tvarset = set(tvars)
                    gvarset = set(gvars)
                    if not tvarset <= gvarset:
                        s_vars = ', '.join(str(t) for t in tvars if t not in gvarset)
                        s_args = ', '.join(str(g) for g in gvars)
                        raise TypeError(f"Some type variables ({s_vars}) are"
                                        f" not listed in {the_base}[{s_args}]")
                    tvars = gvars
            cls.__parameters__ = tuple(tvars)

            # Determine if this is a protocol or a concrete subclass.
            if not cls.__dict__.get('_is_protocol', None):
                cls._is_protocol = any(b is Protocol for b in cls.__bases__)

            # Set (or override) the protocol subclass hook.
            def _proto_hook(other):
                if not cls.__dict__.get('_is_protocol', None):
                    return NotImplemented
                if not getattr(cls, '_is_runtime_protocol', False):
                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
                        return NotImplemented
                    raise TypeError("Instance and class checks can only be used with"
                                    " @runtime protocols")
                if not _is_callable_members_only(cls):
                    if sys._getframe(2).f_globals['__name__'] in ['abc', 'functools']:
                        return NotImplemented
                    raise TypeError("Protocols with non-method members"
                                    " don't support issubclass()")
                if not isinstance(other, type):
                    # Same error as for issubclass(1, int)
                    raise TypeError('issubclass() arg 1 must be a class')
                for attr in _get_protocol_attrs(cls):
                    for base in other.__mro__:
                        if attr in base.__dict__:
                            if base.__dict__[attr] is None:
                                return NotImplemented
                            break
                        annotations = getattr(base, '__annotations__', {})
                        if (isinstance(annotations, typing.Mapping) and
                                attr in annotations and
                                isinstance(other, _ProtocolMeta) and
                                other._is_protocol):
                            break
                    else:
                        return NotImplemented
                return True
            if '__subclasshook__' not in cls.__dict__:
                cls.__subclasshook__ = _proto_hook

            # We have nothing more to do for non-protocols.
            if not cls._is_protocol:
                return

            # Check consistency of bases.
            for base in cls.__bases__:
                if not (base in (object, typing.Generic) or
                        base.__module__ == 'collections.abc' and
                        base.__name__ in _PROTO_WHITELIST or
                        isinstance(base, _ProtocolMeta) and base._is_protocol):
                    raise TypeError('Protocols can only inherit from other'
                                    f' protocols, got {repr(base)}')
            cls.__init__ = _no_init
# 3.6
else:
    from typing import _next_in_mro, _type_check  # noqa

    def _no_init(self, *args, **kwargs):
        if type(self)._is_protocol:
            raise TypeError('Protocols cannot be instantiated')

    class _ProtocolMeta(GenericMeta):
        """Internal metaclass for Protocol.

        This exists so Protocol classes can be generic without deriving
        from Generic.
        """
        def __new__(cls, name, bases, namespace,
                    tvars=None, args=None, origin=None, extra=None, orig_bases=None):
            # This is just a version copied from GenericMeta.__new__ that
            # includes "Protocol" special treatment. (Comments removed for brevity.)
            assert extra is None  # Protocols should not have extra
            if tvars is not None:
                assert origin is not None
                assert all(isinstance(t, typing.TypeVar) for t in tvars), tvars
            else:
                tvars = _type_vars(bases)
                gvars = None
                for base in bases:
                    if base is typing.Generic:
                        raise TypeError("Cannot inherit from plain Generic")
                    if (isinstance(base, GenericMeta) and
                            base.__origin__ in (typing.Generic, Protocol)):
                        if gvars is not None:
                            raise TypeError(
                                "Cannot inherit from Generic[...] or"
                                " Protocol[...] multiple times.")
                        gvars = base.__parameters__
                if gvars is None:
                    gvars = tvars
                else:
                    tvarset = set(tvars)
                    gvarset = set(gvars)
                    if not tvarset <= gvarset:
                        s_vars = ", ".join(str(t) for t in tvars if t not in gvarset)
                        s_args = ", ".join(str(g) for g in gvars)
                        cls_name = "Generic" if any(b.__origin__ is typing.Generic
                                                    for b in bases) else "Protocol"
                        raise TypeError(f"Some type variables ({s_vars}) are"
                                        f" not listed in {cls_name}[{s_args}]")
                    tvars = gvars

            initial_bases = bases
            if (extra is not None and type(extra) is abc.ABCMeta and
                    extra not in bases):
                bases = (extra,) + bases
            bases = tuple(_gorg(b) if isinstance(b, GenericMeta) else b
                          for b in bases)
            if any(isinstance(b, GenericMeta) and b is not typing.Generic for b in bases):
                bases = tuple(b for b in bases if b is not typing.Generic)
            namespace.update({'__origin__': origin, '__extra__': extra})
            self = super(GenericMeta, cls).__new__(cls, name, bases, namespace,
                                                   _root=True)
            super(GenericMeta, self).__setattr__('_gorg',
                                                 self if not origin else
                                                 _gorg(origin))
            self.__parameters__ = tvars
            self.__args__ = tuple(... if a is typing._TypingEllipsis else
                                  () if a is typing._TypingEmpty else
                                  a for a in args) if args else None
            self.__next_in_mro__ = _next_in_mro(self)
            if orig_bases is None:
                self.__orig_bases__ = initial_bases
            elif origin is not None:
                self._abc_registry = origin._abc_registry
                self._abc_cache = origin._abc_cache
            if hasattr(self, '_subs_tree'):
                self.__tree_hash__ = (hash(self._subs_tree()) if origin else
                                      super(GenericMeta, self).__hash__())
            return self

        def __init__(cls, *args, **kwargs):
            super().__init__(*args, **kwargs)
            if not cls.__dict__.get('_is_protocol', None):
                cls._is_protocol = any(b is Protocol or
                                       isinstance(b, _ProtocolMeta) and
                                       b.__origin__ is Protocol
                                       for b in cls.__bases__)
            if cls._is_protocol:
                for base in cls.__mro__[1:]:
                    if not (base in (object, typing.Generic) or
                            base.__module__ == 'collections.abc' and
                            base.__name__ in _PROTO_WHITELIST or
                            isinstance(base, typing.TypingMeta) and base._is_protocol or
                            isinstance(base, GenericMeta) and
                            base.__origin__ is typing.Generic):
                        raise TypeError(f'Protocols can only inherit from other'
                                        f' protocols, got {repr(base)}')

                cls.__init__ = _no_init

            def _proto_hook(other):
                if not cls.__dict__.get('_is_protocol', None):
                    return NotImplemented
                if not isinstance(other, type):
                    # Same error as for issubclass(1, int)
                    raise TypeError('issubclass() arg 1 must be a class')
                for attr in _get_protocol_attrs(cls):
                    for base in other.__mro__:
                        if attr in base.__dict__:
                            if base.__dict__[attr] is None:
                                return NotImplemented
                            break
                        annotations = getattr(base, '__annotations__', {})
                        if (isinstance(annotations, typing.Mapping) and
                                attr in annotations and
                                isinstance(other, _ProtocolMeta) and
                                other._is_protocol):
                            break
                    else:
                        return NotImplemented
                return True
            if '__subclasshook__' not in cls.__dict__:
                cls.__subclasshook__ = _proto_hook

        def __instancecheck__(self, instance):
            # We need this method for situations where attributes are
            # assigned in __init__.
            if ((not getattr(self, '_is_protocol', False) or
                    _is_callable_members_only(self)) and
                    issubclass(instance.__class__, self)):
                return True
            if self._is_protocol:
                if all(hasattr(instance, attr) and
                        (not callable(getattr(self, attr, None)) or
                         getattr(instance, attr) is not None)
                        for attr in _get_protocol_attrs(self)):
                    return True
            return super(GenericMeta, self).__instancecheck__(instance)

        def __subclasscheck__(self, cls):
            if self.__origin__ is not None:
                if sys._getframe(1).f_globals['__name__'] not in ['abc', 'functools']:
                    raise TypeError("Parameterized generics cannot be used with class "
                                    "or instance checks")
                return False
            if (self.__dict__.get('_is_protocol', None) and
                    not self.__dict__.get('_is_runtime_protocol', None)):
                if sys._getframe(1).f_globals['__name__'] in ['abc',
                                                              'functools',
                                                              'typing']:
                    return False
                raise TypeError("Instance and class checks can only be used with"
                                " @runtime protocols")
            if (self.__dict__.get('_is_runtime_protocol', None) and
                    not _is_callable_members_only(self)):
                if sys._getframe(1).f_globals['__name__'] in ['abc',
                                                              'functools',
                                                              'typing']:
                    return super(GenericMeta, self).__subclasscheck__(cls)
                raise TypeError("Protocols with non-method members"
                                " don't support issubclass()")
            return super(GenericMeta, self).__subclasscheck__(cls)

        @typing._tp_cache
        def __getitem__(self, params):
            # We also need to copy this from GenericMeta.__getitem__ to get
            # special treatment of "Protocol". (Comments removed for brevity.)
            if not isinstance(params, tuple):
                params = (params,)
            if not params and _gorg(self) is not typing.Tuple:
                raise TypeError(
                    f"Parameter list to {self.__qualname__}[...] cannot be empty")
            msg = "Parameters to generic types must be types."
            params = tuple(_type_check(p, msg) for p in params)
            if self in (typing.Generic, Protocol):
                if not all(isinstance(p, typing.TypeVar) for p in params):
                    raise TypeError(
                        f"Parameters to {repr(self)}[...] must all be type variables")
                if len(set(params)) != len(params):
                    raise TypeError(
                        f"Parameters to {repr(self)}[...] must all be unique")
                tvars = params
                args = params
            elif self in (typing.Tuple, typing.Callable):
                tvars = _type_vars(params)
                args = params
            elif self.__origin__ in (typing.Generic, Protocol):
                raise TypeError(f"Cannot subscript already-subscripted {repr(self)}")
            else:
                _check_generic(self, params)
                tvars = _type_vars(params)
                args = params

            prepend = (self,) if self.__origin__ is None else ()
            return self.__class__(self.__name__,
                                  prepend + self.__bases__,
                                  _no_slots_copy(self.__dict__),
                                  tvars=tvars,
                                  args=args,
                                  origin=self,
                                  extra=self.__extra__,
                                  orig_bases=self.__orig_bases__)

    class Protocol(metaclass=_ProtocolMeta):
        """Base class for protocol classes. Protocol classes are defined as::

          class Proto(Protocol):
              def meth(self) -> int:
                  ...

        Such classes are primarily used with static type checkers that recognize
        structural subtyping (static duck-typing), for example::

          class C:
              def meth(self) -> int:
                  return 0

          def func(x: Proto) -> int:
              return x.meth()

          func(C())  # Passes static type check

        See PEP 544 for details. Protocol classes decorated with
        @typing_extensions.runtime act as simple-minded runtime protocol that checks
        only the presence of given attributes, ignoring their type signatures.

        Protocol classes can be generic, they are defined as::

          class GenProto(Protocol[T]):
              def meth(self) -> T:
                  ...
        """
        __slots__ = ()
        _is_protocol = True

        def __new__(cls, *args, **kwds):
            if _gorg(cls) is Protocol:
                raise TypeError("Type Protocol cannot be instantiated; "
                                "it can be used only as a base class")
            return typing._generic_new(cls.__next_in_mro__, cls, *args, **kwds)


# 3.8+
if hasattr(typing, 'runtime_checkable'):
    runtime_checkable = typing.runtime_checkable
# 3.6-3.7
else:
    def runtime_checkable(cls):
        """Mark a protocol class as a runtime protocol, so that it
        can be used with isinstance() and issubclass(). Raise TypeError
        if applied to a non-protocol class.

        This allows a simple-minded structural check very similar to the
        one-offs in collections.abc such as Hashable.
        """
        if not isinstance(cls, _ProtocolMeta) or not cls._is_protocol:
            raise TypeError('@runtime_checkable can be only applied to protocol classes,'
                            f' got {cls!r}')
        cls._is_runtime_protocol = True
        return cls


# Exists for backwards compatibility.
runtime = runtime_checkable


# 3.8+
if hasattr(typing, 'SupportsIndex'):
    SupportsIndex = typing.SupportsIndex
# 3.6-3.7
else:
    @runtime_checkable
    class SupportsIndex(Protocol):
        __slots__ = ()

        @abc.abstractmethod
        def __index__(self) -> int:
            pass


if sys.version_info >= (3, 9, 2):
    # The standard library TypedDict in Python 3.8 does not store runtime information
    # about which (if any) keys are optional.  See https://bugs.python.org/issue38834
    # The standard library TypedDict in Python 3.9.0/1 does not honour the "total"
    # keyword with old-style TypedDict().  See https://bugs.python.org/issue42059
    TypedDict = typing.TypedDict
else:
    def _check_fails(cls, other):
        try:
            if sys._getframe(1).f_globals['__name__'] not in ['abc',
                                                              'functools',
                                                              'typing']:
                # Typed dicts are only for static structural subtyping.
                raise TypeError('TypedDict does not support instance and class checks')
        except (AttributeError, ValueError):
            pass
        return False

    def _dict_new(*args, **kwargs):
        if not args:
            raise TypeError('TypedDict.__new__(): not enough arguments')
        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
        return dict(*args, **kwargs)

    _dict_new.__text_signature__ = '($cls, _typename, _fields=None, /, **kwargs)'

    def _typeddict_new(*args, total=True, **kwargs):
        if not args:
            raise TypeError('TypedDict.__new__(): not enough arguments')
        _, args = args[0], args[1:]  # allow the "cls" keyword be passed
        if args:
            typename, args = args[0], args[1:]  # allow the "_typename" keyword be passed
        elif '_typename' in kwargs:
            typename = kwargs.pop('_typename')
            import warnings
            warnings.warn("Passing '_typename' as keyword argument is deprecated",
                          DeprecationWarning, stacklevel=2)
        else:
            raise TypeError("TypedDict.__new__() missing 1 required positional "
                            "argument: '_typename'")
        if args:
            try:
                fields, = args  # allow the "_fields" keyword be passed
            except ValueError:
                raise TypeError('TypedDict.__new__() takes from 2 to 3 '
                                f'positional arguments but {len(args) + 2} '
                                'were given')
        elif '_fields' in kwargs and len(kwargs) == 1:
            fields = kwargs.pop('_fields')
            import warnings
            warnings.warn("Passing '_fields' as keyword argument is deprecated",
                          DeprecationWarning, stacklevel=2)
        else:
            fields = None

        if fields is None:
            fields = kwargs
        elif kwargs:
            raise TypeError("TypedDict takes either a dict or keyword arguments,"
                            " but not both")

        ns = {'__annotations__': dict(fields)}
        try:
            # Setting correct module is necessary to make typed dict classes pickleable.
            ns['__module__'] = sys._getframe(1).f_globals.get('__name__', '__main__')
        except (AttributeError, ValueError):
            pass

        return _TypedDictMeta(typename, (), ns, total=total)

    _typeddict_new.__text_signature__ = ('($cls, _typename, _fields=None,'
                                         ' /, *, total=True, **kwargs)')

    class _TypedDictMeta(type):
        def __init__(cls, name, bases, ns, total=True):
            super().__init__(name, bases, ns)

        def __new__(cls, name, bases, ns, total=True):
            # Create new typed dict class object.
            # This method is called directly when TypedDict is subclassed,
            # or via _typeddict_new when TypedDict is instantiated. This way
            # TypedDict supports all three syntaxes described in its docstring.
            # Subclasses and instances of TypedDict return actual dictionaries
            # via _dict_new.
            ns['__new__'] = _typeddict_new if name == 'TypedDict' else _dict_new
            tp_dict = super().__new__(cls, name, (dict,), ns)

            annotations = {}
            own_annotations = ns.get('__annotations__', {})
            own_annotation_keys = set(own_annotations.keys())
            msg = "TypedDict('Name', {f0: t0, f1: t1, ...}); each t must be a type"
            own_annotations = {
                n: typing._type_check(tp, msg) for n, tp in own_annotations.items()
            }
            required_keys = set()
            optional_keys = set()

            for base in bases:
                annotations.update(base.__dict__.get('__annotations__', {}))
                required_keys.update(base.__dict__.get('__required_keys__', ()))
                optional_keys.update(base.__dict__.get('__optional_keys__', ()))

            annotations.update(own_annotations)
            if total:
                required_keys.update(own_annotation_keys)
            else:
                optional_keys.update(own_annotation_keys)

            tp_dict.__annotations__ = annotations
            tp_dict.__required_keys__ = frozenset(required_keys)
            tp_dict.__optional_keys__ = frozenset(optional_keys)
            if not hasattr(tp_dict, '__total__'):
                tp_dict.__total__ = total
            return tp_dict

        __instancecheck__ = __subclasscheck__ = _check_fails

    TypedDict = _TypedDictMeta('TypedDict', (dict,), {})
    TypedDict.__module__ = __name__
    TypedDict.__doc__ = \
        """A simple typed name space. At runtime it is equivalent to a plain dict.

        TypedDict creates a dictionary type that expects all of its
        instances to have a certain set of keys, with each key
        associated with a value of a consistent type. This expectation
        is not checked at runtime but is only enforced by type checkers.
        Usage::

            class Point2D(TypedDict):
                x: int
                y: int
                label: str

            a: Point2D = {'x': 1, 'y': 2, 'label': 'good'}  # OK
            b: Point2D = {'z': 3, 'label': 'bad'}           # Fails type check

            assert Point2D(x=1, y=2, label='first') == dict(x=1, y=2, label='first')

        The type info can be accessed via the Point2D.__annotations__ dict, and
        the Point2D.__required_keys__ and Point2D.__optional_keys__ frozensets.
        TypedDict supports two additional equivalent forms::

            Point2D = TypedDict('Point2D', x=int, y=int, label=str)
            Point2D = TypedDict('Point2D', {'x': int, 'y': int, 'label': str})

        The class syntax is only supported in Python 3.6+, while two other
        syntax forms work for Python 2.7 and 3.2+
        """


# Python 3.9+ has PEP 593 (Annotated and modified get_type_hints)
if hasattr(typing, 'Annotated'):
    Annotated = typing.Annotated
    get_type_hints = typing.get_type_hints
    # Not exported and not a public API, but needed for get_origin() and get_args()
    # to work.
    _AnnotatedAlias = typing._AnnotatedAlias
# 3.7-3.8
elif PEP_560:
    class _AnnotatedAlias(typing._GenericAlias, _root=True):
        """Runtime representation of an annotated type.

        At its core 'Annotated[t, dec1, dec2, ...]' is an alias for the type 't'
        with extra annotations. The alias behaves like a normal typing alias,
        instantiating is the same as instantiating the underlying type, binding
        it to types is also the same.
        """
        def __init__(self, origin, metadata):
            if isinstance(origin, _AnnotatedAlias):
                metadata = origin.__metadata__ + metadata
                origin = origin.__origin__
            super().__init__(origin, origin)
            self.__metadata__ = metadata

        def copy_with(self, params):
            assert len(params) == 1
            new_type = params[0]
            return _AnnotatedAlias(new_type, self.__metadata__)

        def __repr__(self):
            return (f"typing_extensions.Annotated[{typing._type_repr(self.__origin__)}, "
                    f"{', '.join(repr(a) for a in self.__metadata__)}]")

        def __reduce__(self):
            return operator.getitem, (
                Annotated, (self.__origin__,) + self.__metadata__
            )

        def __eq__(self, other):
            if not isinstance(other, _AnnotatedAlias):
                return NotImplemented
            if self.__origin__ != other.__origin__:
                return False
            return self.__metadata__ == other.__metadata__

        def __hash__(self):
            return hash((self.__origin__, self.__metadata__))

    class Annotated:
        """Add context specific metadata to a type.

        Example: Annotated[int, runtime_check.Unsigned] indicates to the
        hypothetical runtime_check module that this type is an unsigned int.
        Every other consumer of this type can ignore this metadata and treat
        this type as int.

        The first argument to Annotated must be a valid type (and will be in
        the __origin__ field), the remaining arguments are kept as a tuple in
        the __extra__ field.

        Details:

        - It's an error to call `Annotated` with less than two arguments.
        - Nested Annotated are flattened::

            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]

        - Instantiating an annotated type is equivalent to instantiating the
        underlying type::

            Annotated[C, Ann1](5) == C(5)

        - Annotated can be used as a generic type alias::

            Optimized = Annotated[T, runtime.Optimize()]
            Optimized[int] == Annotated[int, runtime.Optimize()]

            OptimizedList = Annotated[List[T], runtime.Optimize()]
            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
        """

        __slots__ = ()

        def __new__(cls, *args, **kwargs):
            raise TypeError("Type Annotated cannot be instantiated.")

        @typing._tp_cache
        def __class_getitem__(cls, params):
            if not isinstance(params, tuple) or len(params) < 2:
                raise TypeError("Annotated[...] should be used "
                                "with at least two arguments (a type and an "
                                "annotation).")
            msg = "Annotated[t, ...]: t must be a type."
            origin = typing._type_check(params[0], msg)
            metadata = tuple(params[1:])
            return _AnnotatedAlias(origin, metadata)

        def __init_subclass__(cls, *args, **kwargs):
            raise TypeError(
                f"Cannot subclass {cls.__module__}.Annotated"
            )

    def _strip_annotations(t):
        """Strips the annotations from a given type.
        """
        if isinstance(t, _AnnotatedAlias):
            return _strip_annotations(t.__origin__)
        if isinstance(t, typing._GenericAlias):
            stripped_args = tuple(_strip_annotations(a) for a in t.__args__)
            if stripped_args == t.__args__:
                return t
            res = t.copy_with(stripped_args)
            res._special = t._special
            return res
        return t

    def get_type_hints(obj, globalns=None, localns=None, include_extras=False):
        """Return type hints for an object.

        This is often the same as obj.__annotations__, but it handles
        forward references encoded as string literals, adds Optional[t] if a
        default value equal to None is set and recursively replaces all
        'Annotated[T, ...]' with 'T' (unless 'include_extras=True').

        The argument may be a module, class, method, or function. The annotations
        are returned as a dictionary. For classes, annotations include also
        inherited members.

        TypeError is raised if the argument is not of a type that can contain
        annotations, and an empty dictionary is returned if no annotations are
        present.

        BEWARE -- the behavior of globalns and localns is counterintuitive
        (unless you are familiar with how eval() and exec() work).  The
        search order is locals first, then globals.

        - If no dict arguments are passed, an attempt is made to use the
          globals from obj (or the respective module's globals for classes),
          and these are also used as the locals.  If the object does not appear
          to have globals, an empty dictionary is used.

        - If one dict argument is passed, it is used for both globals and
          locals.

        - If two dict arguments are passed, they specify globals and
          locals, respectively.
        """
        hint = typing.get_type_hints(obj, globalns=globalns, localns=localns)
        if include_extras:
            return hint
        return {k: _strip_annotations(t) for k, t in hint.items()}
# 3.6
else:

    def _is_dunder(name):
        """Returns True if name is a __dunder_variable_name__."""
        return len(name) > 4 and name.startswith('__') and name.endswith('__')

    # Prior to Python 3.7 types did not have `copy_with`. A lot of the equality
    # checks, argument expansion etc. are done on the _subs_tre. As a result we
    # can't provide a get_type_hints function that strips out annotations.

    class AnnotatedMeta(typing.GenericMeta):
        """Metaclass for Annotated"""

        def __new__(cls, name, bases, namespace, **kwargs):
            if any(b is not object for b in bases):
                raise TypeError("Cannot subclass " + str(Annotated))
            return super().__new__(cls, name, bases, namespace, **kwargs)

        @property
        def __metadata__(self):
            return self._subs_tree()[2]

        def _tree_repr(self, tree):
            cls, origin, metadata = tree
            if not isinstance(origin, tuple):
                tp_repr = typing._type_repr(origin)
            else:
                tp_repr = origin[0]._tree_repr(origin)
            metadata_reprs = ", ".join(repr(arg) for arg in metadata)
            return f'{cls}[{tp_repr}, {metadata_reprs}]'

        def _subs_tree(self, tvars=None, args=None):  # noqa
            if self is Annotated:
                return Annotated
            res = super()._subs_tree(tvars=tvars, args=args)
            # Flatten nested Annotated
            if isinstance(res[1], tuple) and res[1][0] is Annotated:
                sub_tp = res[1][1]
                sub_annot = res[1][2]
                return (Annotated, sub_tp, sub_annot + res[2])
            return res

        def _get_cons(self):
            """Return the class used to create instance of this type."""
            if self.__origin__ is None:
                raise TypeError("Cannot get the underlying type of a "
                                "non-specialized Annotated type.")
            tree = self._subs_tree()
            while isinstance(tree, tuple) and tree[0] is Annotated:
                tree = tree[1]
            if isinstance(tree, tuple):
                return tree[0]
            else:
                return tree

        @typing._tp_cache
        def __getitem__(self, params):
            if not isinstance(params, tuple):
                params = (params,)
            if self.__origin__ is not None:  # specializing an instantiated type
                return super().__getitem__(params)
            elif not isinstance(params, tuple) or len(params) < 2:
                raise TypeError("Annotated[...] should be instantiated "
                                "with at least two arguments (a type and an "
                                "annotation).")
            else:
                msg = "Annotated[t, ...]: t must be a type."
                tp = typing._type_check(params[0], msg)
                metadata = tuple(params[1:])
            return self.__class__(
                self.__name__,
                self.__bases__,
                _no_slots_copy(self.__dict__),
                tvars=_type_vars((tp,)),
                # Metadata is a tuple so it won't be touched by _replace_args et al.
                args=(tp, metadata),
                origin=self,
            )

        def __call__(self, *args, **kwargs):
            cons = self._get_cons()
            result = cons(*args, **kwargs)
            try:
                result.__orig_class__ = self
            except AttributeError:
                pass
            return result

        def __getattr__(self, attr):
            # For simplicity we just don't relay all dunder names
            if self.__origin__ is not None and not _is_dunder(attr):
                return getattr(self._get_cons(), attr)
            raise AttributeError(attr)

        def __setattr__(self, attr, value):
            if _is_dunder(attr) or attr.startswith('_abc_'):
                super().__setattr__(attr, value)
            elif self.__origin__ is None:
                raise AttributeError(attr)
            else:
                setattr(self._get_cons(), attr, value)

        def __instancecheck__(self, obj):
            raise TypeError("Annotated cannot be used with isinstance().")

        def __subclasscheck__(self, cls):
            raise TypeError("Annotated cannot be used with issubclass().")

    class Annotated(metaclass=AnnotatedMeta):
        """Add context specific metadata to a type.

        Example: Annotated[int, runtime_check.Unsigned] indicates to the
        hypothetical runtime_check module that this type is an unsigned int.
        Every other consumer of this type can ignore this metadata and treat
        this type as int.

        The first argument to Annotated must be a valid type, the remaining
        arguments are kept as a tuple in the __metadata__ field.

        Details:

        - It's an error to call `Annotated` with less than two arguments.
        - Nested Annotated are flattened::

            Annotated[Annotated[T, Ann1, Ann2], Ann3] == Annotated[T, Ann1, Ann2, Ann3]

        - Instantiating an annotated type is equivalent to instantiating the
        underlying type::

            Annotated[C, Ann1](5) == C(5)

        - Annotated can be used as a generic type alias::

            Optimized = Annotated[T, runtime.Optimize()]
            Optimized[int] == Annotated[int, runtime.Optimize()]

            OptimizedList = Annotated[List[T], runtime.Optimize()]
            OptimizedList[int] == Annotated[List[int], runtime.Optimize()]
        """

# Python 3.8 has get_origin() and get_args() but those implementations aren't
# Annotated-aware, so we can't use those. Python 3.9's versions don't support
# ParamSpecArgs and ParamSpecKwargs, so only Python 3.10's versions will do.
if sys.version_info[:2] >= (3, 10):
    get_origin = typing.get_origin
    get_args = typing.get_args
# 3.7-3.9
elif PEP_560:
    try:
        # 3.9+
        from typing import _BaseGenericAlias
    except ImportError:
        _BaseGenericAlias = typing._GenericAlias
    try:
        # 3.9+
        from typing import GenericAlias
    except ImportError:
        GenericAlias = typing._GenericAlias

    def get_origin(tp):
        """Get the unsubscripted version of a type.

        This supports generic types, Callable, Tuple, Union, Literal, Final, ClassVar
        and Annotated. Return None for unsupported types. Examples::

            get_origin(Literal[42]) is Literal
            get_origin(int) is None
            get_origin(ClassVar[int]) is ClassVar
            get_origin(Generic) is Generic
            get_origin(Generic[T]) is Generic
            get_origin(Union[T, int]) is Union
            get_origin(List[Tuple[T, T]][int]) == list
            get_origin(P.args) is P
        """
        if isinstance(tp, _AnnotatedAlias):
            return Annotated
        if isinstance(tp, (typing._GenericAlias, GenericAlias, _BaseGenericAlias,
                           ParamSpecArgs, ParamSpecKwargs)):
            return tp.__origin__
        if tp is typing.Generic:
            return typing.Generic
        return None

    def get_args(tp):
        """Get type arguments with all substitutions performed.

        For unions, basic simplifications used by Union constructor are performed.
        Examples::
            get_args(Dict[str, int]) == (str, int)
            get_args(int) == ()
            get_args(Union[int, Union[T, int], str][int]) == (int, str)
            get_args(Union[int, Tuple[T, int]][str]) == (int, Tuple[str, int])
            get_args(Callable[[], T][int]) == ([], int)
        """
        if isinstance(tp, _AnnotatedAlias):
            return (tp.__origin__,) + tp.__metadata__
        if isinstance(tp, (typing._GenericAlias, GenericAlias)):
            if getattr(tp, "_special", False):
                return ()
            res = tp.__args__
            if get_origin(tp) is collections.abc.Callable and res[0] is not Ellipsis:
                res = (list(res[:-1]), res[-1])
            return res
        return ()


# 3.10+
if hasattr(typing, 'TypeAlias'):
    TypeAlias = typing.TypeAlias
# 3.9
elif sys.version_info[:2] >= (3, 9):
    class _TypeAliasForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    @_TypeAliasForm
    def TypeAlias(self, parameters):
        """Special marker indicating that an assignment should
        be recognized as a proper type alias definition by type
        checkers.

        For example::

            Predicate: TypeAlias = Callable[..., bool]

        It's invalid when used anywhere except as in the example above.
        """
        raise TypeError(f"{self} is not subscriptable")
# 3.7-3.8
elif sys.version_info[:2] >= (3, 7):
    class _TypeAliasForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    TypeAlias = _TypeAliasForm('TypeAlias',
                               doc="""Special marker indicating that an assignment should
                               be recognized as a proper type alias definition by type
                               checkers.

                               For example::

                                   Predicate: TypeAlias = Callable[..., bool]

                               It's invalid when used anywhere except as in the example
                               above.""")
# 3.6
else:
    class _TypeAliasMeta(typing.TypingMeta):
        """Metaclass for TypeAlias"""

        def __repr__(self):
            return 'typing_extensions.TypeAlias'

    class _TypeAliasBase(typing._FinalTypingBase, metaclass=_TypeAliasMeta, _root=True):
        """Special marker indicating that an assignment should
        be recognized as a proper type alias definition by type
        checkers.

        For example::

            Predicate: TypeAlias = Callable[..., bool]

        It's invalid when used anywhere except as in the example above.
        """
        __slots__ = ()

        def __instancecheck__(self, obj):
            raise TypeError("TypeAlias cannot be used with isinstance().")

        def __subclasscheck__(self, cls):
            raise TypeError("TypeAlias cannot be used with issubclass().")

        def __repr__(self):
            return 'typing_extensions.TypeAlias'

    TypeAlias = _TypeAliasBase(_root=True)


# Python 3.10+ has PEP 612
if hasattr(typing, 'ParamSpecArgs'):
    ParamSpecArgs = typing.ParamSpecArgs
    ParamSpecKwargs = typing.ParamSpecKwargs
# 3.6-3.9
else:
    class _Immutable:
        """Mixin to indicate that object should not be copied."""
        __slots__ = ()

        def __copy__(self):
            return self

        def __deepcopy__(self, memo):
            return self

    class ParamSpecArgs(_Immutable):
        """The args for a ParamSpec object.

        Given a ParamSpec object P, P.args is an instance of ParamSpecArgs.

        ParamSpecArgs objects have a reference back to their ParamSpec:

        P.args.__origin__ is P

        This type is meant for runtime introspection and has no special meaning to
        static type checkers.
        """
        def __init__(self, origin):
            self.__origin__ = origin

        def __repr__(self):
            return f"{self.__origin__.__name__}.args"

    class ParamSpecKwargs(_Immutable):
        """The kwargs for a ParamSpec object.

        Given a ParamSpec object P, P.kwargs is an instance of ParamSpecKwargs.

        ParamSpecKwargs objects have a reference back to their ParamSpec:

        P.kwargs.__origin__ is P

        This type is meant for runtime introspection and has no special meaning to
        static type checkers.
        """
        def __init__(self, origin):
            self.__origin__ = origin

        def __repr__(self):
            return f"{self.__origin__.__name__}.kwargs"

# 3.10+
if hasattr(typing, 'ParamSpec'):
    ParamSpec = typing.ParamSpec
# 3.6-3.9
else:

    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
    class ParamSpec(list):
        """Parameter specification variable.

        Usage::

           P = ParamSpec('P')

        Parameter specification variables exist primarily for the benefit of static
        type checkers.  They are used to forward the parameter types of one
        callable to another callable, a pattern commonly found in higher order
        functions and decorators.  They are only valid when used in ``Concatenate``,
        or s the first argument to ``Callable``. In Python 3.10 and higher,
        they are also supported in user-defined Generics at runtime.
        See class Generic for more information on generic types.  An
        example for annotating a decorator::

           T = TypeVar('T')
           P = ParamSpec('P')

           def add_logging(f: Callable[P, T]) -> Callable[P, T]:
               '''A type-safe decorator to add logging to a function.'''
               def inner(*args: P.args, **kwargs: P.kwargs) -> T:
                   logging.info(f'{f.__name__} was called')
                   return f(*args, **kwargs)
               return inner

           @add_logging
           def add_two(x: float, y: float) -> float:
               '''Add two numbers together.'''
               return x + y

        Parameter specification variables defined with covariant=True or
        contravariant=True can be used to declare covariant or contravariant
        generic types.  These keyword arguments are valid, but their actual semantics
        are yet to be decided.  See PEP 612 for details.

        Parameter specification variables can be introspected. e.g.:

           P.__name__ == 'T'
           P.__bound__ == None
           P.__covariant__ == False
           P.__contravariant__ == False

        Note that only parameter specification variables defined in global scope can
        be pickled.
        """

        # Trick Generic __parameters__.
        __class__ = typing.TypeVar

        @property
        def args(self):
            return ParamSpecArgs(self)

        @property
        def kwargs(self):
            return ParamSpecKwargs(self)

        def __init__(self, name, *, bound=None, covariant=False, contravariant=False):
            super().__init__([self])
            self.__name__ = name
            self.__covariant__ = bool(covariant)
            self.__contravariant__ = bool(contravariant)
            if bound:
                self.__bound__ = typing._type_check(bound, 'Bound must be a type.')
            else:
                self.__bound__ = None

            # for pickling:
            try:
                def_mod = sys._getframe(1).f_globals.get('__name__', '__main__')
            except (AttributeError, ValueError):
                def_mod = None
            if def_mod != 'typing_extensions':
                self.__module__ = def_mod

        def __repr__(self):
            if self.__covariant__:
                prefix = '+'
            elif self.__contravariant__:
                prefix = '-'
            else:
                prefix = '~'
            return prefix + self.__name__

        def __hash__(self):
            return object.__hash__(self)

        def __eq__(self, other):
            return self is other

        def __reduce__(self):
            return self.__name__

        # Hack to get typing._type_check to pass.
        def __call__(self, *args, **kwargs):
            pass

        if not PEP_560:
            # Only needed in 3.6.
            def _get_type_vars(self, tvars):
                if self not in tvars:
                    tvars.append(self)


# 3.6-3.9
if not hasattr(typing, 'Concatenate'):
    # Inherits from list as a workaround for Callable checks in Python < 3.9.2.
    class _ConcatenateGenericAlias(list):

        # Trick Generic into looking into this for __parameters__.
        if PEP_560:
            __class__ = typing._GenericAlias
        else:
            __class__ = typing._TypingBase

        # Flag in 3.8.
        _special = False
        # Attribute in 3.6 and earlier.
        _gorg = typing.Generic

        def __init__(self, origin, args):
            super().__init__(args)
            self.__origin__ = origin
            self.__args__ = args

        def __repr__(self):
            _type_repr = typing._type_repr
            return (f'{_type_repr(self.__origin__)}'
                    f'[{", ".join(_type_repr(arg) for arg in self.__args__)}]')

        def __hash__(self):
            return hash((self.__origin__, self.__args__))

        # Hack to get typing._type_check to pass in Generic.
        def __call__(self, *args, **kwargs):
            pass

        @property
        def __parameters__(self):
            return tuple(
                tp for tp in self.__args__ if isinstance(tp, (typing.TypeVar, ParamSpec))
            )

        if not PEP_560:
            # Only required in 3.6.
            def _get_type_vars(self, tvars):
                if self.__origin__ and self.__parameters__:
                    typing._get_type_vars(self.__parameters__, tvars)


# 3.6-3.9
@typing._tp_cache
def _concatenate_getitem(self, parameters):
    if parameters == ():
        raise TypeError("Cannot take a Concatenate of no types.")
    if not isinstance(parameters, tuple):
        parameters = (parameters,)
    if not isinstance(parameters[-1], ParamSpec):
        raise TypeError("The last parameter to Concatenate should be a "
                        "ParamSpec variable.")
    msg = "Concatenate[arg, ...]: each arg must be a type."
    parameters = tuple(typing._type_check(p, msg) for p in parameters)
    return _ConcatenateGenericAlias(self, parameters)


# 3.10+
if hasattr(typing, 'Concatenate'):
    Concatenate = typing.Concatenate
    _ConcatenateGenericAlias = typing._ConcatenateGenericAlias # noqa
# 3.9
elif sys.version_info[:2] >= (3, 9):
    @_TypeAliasForm
    def Concatenate(self, parameters):
        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
        higher order function which adds, removes or transforms parameters of a
        callable.

        For example::

           Callable[Concatenate[int, P], int]

        See PEP 612 for detailed information.
        """
        return _concatenate_getitem(self, parameters)
# 3.7-8
elif sys.version_info[:2] >= (3, 7):
    class _ConcatenateForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            return _concatenate_getitem(self, parameters)

    Concatenate = _ConcatenateForm(
        'Concatenate',
        doc="""Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
        higher order function which adds, removes or transforms parameters of a
        callable.

        For example::

           Callable[Concatenate[int, P], int]

        See PEP 612 for detailed information.
        """)
# 3.6
else:
    class _ConcatenateAliasMeta(typing.TypingMeta):
        """Metaclass for Concatenate."""

        def __repr__(self):
            return 'typing_extensions.Concatenate'

    class _ConcatenateAliasBase(typing._FinalTypingBase,
                                metaclass=_ConcatenateAliasMeta,
                                _root=True):
        """Used in conjunction with ``ParamSpec`` and ``Callable`` to represent a
        higher order function which adds, removes or transforms parameters of a
        callable.

        For example::

           Callable[Concatenate[int, P], int]

        See PEP 612 for detailed information.
        """
        __slots__ = ()

        def __instancecheck__(self, obj):
            raise TypeError("Concatenate cannot be used with isinstance().")

        def __subclasscheck__(self, cls):
            raise TypeError("Concatenate cannot be used with issubclass().")

        def __repr__(self):
            return 'typing_extensions.Concatenate'

        def __getitem__(self, parameters):
            return _concatenate_getitem(self, parameters)

    Concatenate = _ConcatenateAliasBase(_root=True)

# 3.10+
if hasattr(typing, 'TypeGuard'):
    TypeGuard = typing.TypeGuard
# 3.9
elif sys.version_info[:2] >= (3, 9):
    class _TypeGuardForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    @_TypeGuardForm
    def TypeGuard(self, parameters):
        """Special typing form used to annotate the return type of a user-defined
        type guard function.  ``TypeGuard`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.

        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".

        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
        return type to alert static type checkers to this intention.

        Using  ``-> TypeGuard`` tells the static type checker that for a given
        function:

        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the type inside ``TypeGuard``.

        For example::

            def is_str(val: Union[str, float]):
                # "isinstance" type guard
                if isinstance(val, str):
                    # Type of ``val`` is narrowed to ``str``
                    ...
                else:
                    # Else, type of ``val`` is narrowed to ``float``.
                    ...

        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
        form of ``TypeA`` (it can even be a wider form) and this may lead to
        type-unsafe results.  The main reason is to allow for things like
        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
        a subtype of the former, since ``List`` is invariant.  The responsibility of
        writing type-safe type guards is left to the user.

        ``TypeGuard`` also works with type variables.  For more information, see
        PEP 647 (User-Defined Type Guards).
        """
        item = typing._type_check(parameters, f'{self} accepts only single type.')
        return typing._GenericAlias(self, (item,))
# 3.7-3.8
elif sys.version_info[:2] >= (3, 7):
    class _TypeGuardForm(typing._SpecialForm, _root=True):

        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            item = typing._type_check(parameters,
                                      f'{self._name} accepts only a single type')
            return typing._GenericAlias(self, (item,))

    TypeGuard = _TypeGuardForm(
        'TypeGuard',
        doc="""Special typing form used to annotate the return type of a user-defined
        type guard function.  ``TypeGuard`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.

        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".

        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
        return type to alert static type checkers to this intention.

        Using  ``-> TypeGuard`` tells the static type checker that for a given
        function:

        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the type inside ``TypeGuard``.

        For example::

            def is_str(val: Union[str, float]):
                # "isinstance" type guard
                if isinstance(val, str):
                    # Type of ``val`` is narrowed to ``str``
                    ...
                else:
                    # Else, type of ``val`` is narrowed to ``float``.
                    ...

        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
        form of ``TypeA`` (it can even be a wider form) and this may lead to
        type-unsafe results.  The main reason is to allow for things like
        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
        a subtype of the former, since ``List`` is invariant.  The responsibility of
        writing type-safe type guards is left to the user.

        ``TypeGuard`` also works with type variables.  For more information, see
        PEP 647 (User-Defined Type Guards).
        """)
# 3.6
else:
    class _TypeGuard(typing._FinalTypingBase, _root=True):
        """Special typing form used to annotate the return type of a user-defined
        type guard function.  ``TypeGuard`` only accepts a single type argument.
        At runtime, functions marked this way should return a boolean.

        ``TypeGuard`` aims to benefit *type narrowing* -- a technique used by static
        type checkers to determine a more precise type of an expression within a
        program's code flow.  Usually type narrowing is done by analyzing
        conditional code flow and applying the narrowing to a block of code.  The
        conditional expression here is sometimes referred to as a "type guard".

        Sometimes it would be convenient to use a user-defined boolean function
        as a type guard.  Such a function should use ``TypeGuard[...]`` as its
        return type to alert static type checkers to this intention.

        Using  ``-> TypeGuard`` tells the static type checker that for a given
        function:

        1. The return value is a boolean.
        2. If the return value is ``True``, the type of its argument
        is the type inside ``TypeGuard``.

        For example::

            def is_str(val: Union[str, float]):
                # "isinstance" type guard
                if isinstance(val, str):
                    # Type of ``val`` is narrowed to ``str``
                    ...
                else:
                    # Else, type of ``val`` is narrowed to ``float``.
                    ...

        Strict type narrowing is not enforced -- ``TypeB`` need not be a narrower
        form of ``TypeA`` (it can even be a wider form) and this may lead to
        type-unsafe results.  The main reason is to allow for things like
        narrowing ``List[object]`` to ``List[str]`` even though the latter is not
        a subtype of the former, since ``List`` is invariant.  The responsibility of
        writing type-safe type guards is left to the user.

        ``TypeGuard`` also works with type variables.  For more information, see
        PEP 647 (User-Defined Type Guards).
        """

        __slots__ = ('__type__',)

        def __init__(self, tp=None, **kwds):
            self.__type__ = tp

        def __getitem__(self, item):
            cls = type(self)
            if self.__type__ is None:
                return cls(typing._type_check(item,
                           f'{cls.__name__[1:]} accepts only a single type.'),
                           _root=True)
            raise TypeError(f'{cls.__name__[1:]} cannot be further subscripted')

        def _eval_type(self, globalns, localns):
            new_tp = typing._eval_type(self.__type__, globalns, localns)
            if new_tp == self.__type__:
                return self
            return type(self)(new_tp, _root=True)

        def __repr__(self):
            r = super().__repr__()
            if self.__type__ is not None:
                r += f'[{typing._type_repr(self.__type__)}]'
            return r

        def __hash__(self):
            return hash((type(self).__name__, self.__type__))

        def __eq__(self, other):
            if not isinstance(other, _TypeGuard):
                return NotImplemented
            if self.__type__ is not None:
                return self.__type__ == other.__type__
            return self is other

    TypeGuard = _TypeGuard(_root=True)

if hasattr(typing, "Self"):
    Self = typing.Self
elif sys.version_info[:2] >= (3, 7):
    # Vendored from cpython typing._SpecialFrom
    class _SpecialForm(typing._Final, _root=True):
        __slots__ = ('_name', '__doc__', '_getitem')

        def __init__(self, getitem):
            self._getitem = getitem
            self._name = getitem.__name__
            self.__doc__ = getitem.__doc__

        def __getattr__(self, item):
            if item in {'__name__', '__qualname__'}:
                return self._name

            raise AttributeError(item)

        def __mro_entries__(self, bases):
            raise TypeError(f"Cannot subclass {self!r}")

        def __repr__(self):
            return f'typing_extensions.{self._name}'

        def __reduce__(self):
            return self._name

        def __call__(self, *args, **kwds):
            raise TypeError(f"Cannot instantiate {self!r}")

        def __or__(self, other):
            return typing.Union[self, other]

        def __ror__(self, other):
            return typing.Union[other, self]

        def __instancecheck__(self, obj):
            raise TypeError(f"{self} cannot be used with isinstance()")

        def __subclasscheck__(self, cls):
            raise TypeError(f"{self} cannot be used with issubclass()")

        @typing._tp_cache
        def __getitem__(self, parameters):
            return self._getitem(self, parameters)

    @_SpecialForm
    def Self(self, params):
        """Used to spell the type of "self" in classes.

        Example::

          from typing import Self

          class ReturnsSelf:
              def parse(self, data: bytes) -> Self:
                  ...
                  return self

        """

        raise TypeError(f"{self} is not subscriptable")
else:
    class _Self(typing._FinalTypingBase, _root=True):
        """Used to spell the type of "self" in classes.

        Example::

          from typing import Self

          class ReturnsSelf:
              def parse(self, data: bytes) -> Self:
                  ...
                  return self

        """

        __slots__ = ()

        def __instancecheck__(self, obj):
            raise TypeError(f"{self} cannot be used with isinstance().")

        def __subclasscheck__(self, cls):
            raise TypeError(f"{self} cannot be used with issubclass().")

    Self = _Self(_root=True)


if hasattr(typing, 'Required'):
    Required = typing.Required
    NotRequired = typing.NotRequired
elif sys.version_info[:2] >= (3, 9):
    class _ExtensionsSpecialForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

    @_ExtensionsSpecialForm
    def Required(self, parameters):
        """A special typing construct to mark a key of a total=False TypedDict
        as required. For example:

            class Movie(TypedDict, total=False):
                title: Required[str]
                year: int

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )

        There is no runtime checking that a required key is actually provided
        when instantiating a related TypedDict.
        """
        item = typing._type_check(parameters, f'{self._name} accepts only single type')
        return typing._GenericAlias(self, (item,))

    @_ExtensionsSpecialForm
    def NotRequired(self, parameters):
        """A special typing construct to mark a key of a TypedDict as
        potentially missing. For example:

            class Movie(TypedDict):
                title: str
                year: NotRequired[int]

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
        """
        item = typing._type_check(parameters, f'{self._name} accepts only single type')
        return typing._GenericAlias(self, (item,))

elif sys.version_info[:2] >= (3, 7):
    class _RequiredForm(typing._SpecialForm, _root=True):
        def __repr__(self):
            return 'typing_extensions.' + self._name

        def __getitem__(self, parameters):
            item = typing._type_check(parameters,
                                      '{} accepts only single type'.format(self._name))
            return typing._GenericAlias(self, (item,))

    Required = _RequiredForm(
        'Required',
        doc="""A special typing construct to mark a key of a total=False TypedDict
        as required. For example:

            class Movie(TypedDict, total=False):
                title: Required[str]
                year: int

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )

        There is no runtime checking that a required key is actually provided
        when instantiating a related TypedDict.
        """)
    NotRequired = _RequiredForm(
        'NotRequired',
        doc="""A special typing construct to mark a key of a TypedDict as
        potentially missing. For example:

            class Movie(TypedDict):
                title: str
                year: NotRequired[int]

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
        """)
else:
    # NOTE: Modeled after _Final's implementation when _FinalTypingBase available
    class _MaybeRequired(typing._FinalTypingBase, _root=True):
        __slots__ = ('__type__',)

        def __init__(self, tp=None, **kwds):
            self.__type__ = tp

        def __getitem__(self, item):
            cls = type(self)
            if self.__type__ is None:
                return cls(typing._type_check(item,
                           '{} accepts only single type.'.format(cls.__name__[1:])),
                           _root=True)
            raise TypeError('{} cannot be further subscripted'
                            .format(cls.__name__[1:]))

        def _eval_type(self, globalns, localns):
            new_tp = typing._eval_type(self.__type__, globalns, localns)
            if new_tp == self.__type__:
                return self
            return type(self)(new_tp, _root=True)

        def __repr__(self):
            r = super().__repr__()
            if self.__type__ is not None:
                r += '[{}]'.format(typing._type_repr(self.__type__))
            return r

        def __hash__(self):
            return hash((type(self).__name__, self.__type__))

        def __eq__(self, other):
            if not isinstance(other, type(self)):
                return NotImplemented
            if self.__type__ is not None:
                return self.__type__ == other.__type__
            return self is other

    class _Required(_MaybeRequired, _root=True):
        """A special typing construct to mark a key of a total=False TypedDict
        as required. For example:

            class Movie(TypedDict, total=False):
                title: Required[str]
                year: int

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )

        There is no runtime checking that a required key is actually provided
        when instantiating a related TypedDict.
        """

    class _NotRequired(_MaybeRequired, _root=True):
        """A special typing construct to mark a key of a TypedDict as
        potentially missing. For example:

            class Movie(TypedDict):
                title: str
                year: NotRequired[int]

            m = Movie(
                title='The Matrix',  # typechecker error if key is omitted
                year=1999,
            )
        """

    Required = _Required(_root=True)
    NotRequired = _NotRequired(_root=True)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/vendored.txt0000644000175100001730000000045114467657412021676 0ustar00runnerdockerpackaging==23.1
ordered-set==3.1.1
more_itertools==8.8.0
jaraco.text==3.7.0
importlib_resources==5.10.2
importlib_metadata==6.0.0
# required for importlib_metadata on older Pythons
typing_extensions==4.0.1
# required for importlib_resources and _metadata on older Pythons
zipp==3.7.0
tomli==2.0.1
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5355504
setuptools-68.1.2/setuptools/_vendor/zipp-3.7.0.dist-info/0000755000175100001730000000000014467657444022654 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/zipp-3.7.0.dist-info/top_level.txt0000644000175100001730000000000514467657412025374 0ustar00runnerdockerzipp
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/_vendor/zipp.py0000644000175100001730000002035114467657412020664 0ustar00runnerdockerimport io
import posixpath
import zipfile
import itertools
import contextlib
import sys
import pathlib

if sys.version_info < (3, 7):
    from collections import OrderedDict
else:
    OrderedDict = dict


__all__ = ['Path']


def _parents(path):
    """
    Given a path with elements separated by
    posixpath.sep, generate all parents of that path.

    >>> list(_parents('b/d'))
    ['b']
    >>> list(_parents('/b/d/'))
    ['/b']
    >>> list(_parents('b/d/f/'))
    ['b/d', 'b']
    >>> list(_parents('b'))
    []
    >>> list(_parents(''))
    []
    """
    return itertools.islice(_ancestry(path), 1, None)


def _ancestry(path):
    """
    Given a path with elements separated by
    posixpath.sep, generate all elements of that path

    >>> list(_ancestry('b/d'))
    ['b/d', 'b']
    >>> list(_ancestry('/b/d/'))
    ['/b/d', '/b']
    >>> list(_ancestry('b/d/f/'))
    ['b/d/f', 'b/d', 'b']
    >>> list(_ancestry('b'))
    ['b']
    >>> list(_ancestry(''))
    []
    """
    path = path.rstrip(posixpath.sep)
    while path and path != posixpath.sep:
        yield path
        path, tail = posixpath.split(path)


_dedupe = OrderedDict.fromkeys
"""Deduplicate an iterable in original order"""


def _difference(minuend, subtrahend):
    """
    Return items in minuend not in subtrahend, retaining order
    with O(1) lookup.
    """
    return itertools.filterfalse(set(subtrahend).__contains__, minuend)


class CompleteDirs(zipfile.ZipFile):
    """
    A ZipFile subclass that ensures that implied directories
    are always included in the namelist.
    """

    @staticmethod
    def _implied_dirs(names):
        parents = itertools.chain.from_iterable(map(_parents, names))
        as_dirs = (p + posixpath.sep for p in parents)
        return _dedupe(_difference(as_dirs, names))

    def namelist(self):
        names = super(CompleteDirs, self).namelist()
        return names + list(self._implied_dirs(names))

    def _name_set(self):
        return set(self.namelist())

    def resolve_dir(self, name):
        """
        If the name represents a directory, return that name
        as a directory (with the trailing slash).
        """
        names = self._name_set()
        dirname = name + '/'
        dir_match = name not in names and dirname in names
        return dirname if dir_match else name

    @classmethod
    def make(cls, source):
        """
        Given a source (filename or zipfile), return an
        appropriate CompleteDirs subclass.
        """
        if isinstance(source, CompleteDirs):
            return source

        if not isinstance(source, zipfile.ZipFile):
            return cls(_pathlib_compat(source))

        # Only allow for FastLookup when supplied zipfile is read-only
        if 'r' not in source.mode:
            cls = CompleteDirs

        source.__class__ = cls
        return source


class FastLookup(CompleteDirs):
    """
    ZipFile subclass to ensure implicit
    dirs exist and are resolved rapidly.
    """

    def namelist(self):
        with contextlib.suppress(AttributeError):
            return self.__names
        self.__names = super(FastLookup, self).namelist()
        return self.__names

    def _name_set(self):
        with contextlib.suppress(AttributeError):
            return self.__lookup
        self.__lookup = super(FastLookup, self)._name_set()
        return self.__lookup


def _pathlib_compat(path):
    """
    For path-like objects, convert to a filename for compatibility
    on Python 3.6.1 and earlier.
    """
    try:
        return path.__fspath__()
    except AttributeError:
        return str(path)


class Path:
    """
    A pathlib-compatible interface for zip files.

    Consider a zip file with this structure::

        .
        ├── a.txt
        └── b
            ├── c.txt
            └── d
                └── e.txt

    >>> data = io.BytesIO()
    >>> zf = zipfile.ZipFile(data, 'w')
    >>> zf.writestr('a.txt', 'content of a')
    >>> zf.writestr('b/c.txt', 'content of c')
    >>> zf.writestr('b/d/e.txt', 'content of e')
    >>> zf.filename = 'mem/abcde.zip'

    Path accepts the zipfile object itself or a filename

    >>> root = Path(zf)

    From there, several path operations are available.

    Directory iteration (including the zip file itself):

    >>> a, b = root.iterdir()
    >>> a
    Path('mem/abcde.zip', 'a.txt')
    >>> b
    Path('mem/abcde.zip', 'b/')

    name property:

    >>> b.name
    'b'

    join with divide operator:

    >>> c = b / 'c.txt'
    >>> c
    Path('mem/abcde.zip', 'b/c.txt')
    >>> c.name
    'c.txt'

    Read text:

    >>> c.read_text()
    'content of c'

    existence:

    >>> c.exists()
    True
    >>> (b / 'missing.txt').exists()
    False

    Coercion to string:

    >>> import os
    >>> str(c).replace(os.sep, posixpath.sep)
    'mem/abcde.zip/b/c.txt'

    At the root, ``name``, ``filename``, and ``parent``
    resolve to the zipfile. Note these attributes are not
    valid and will raise a ``ValueError`` if the zipfile
    has no filename.

    >>> root.name
    'abcde.zip'
    >>> str(root.filename).replace(os.sep, posixpath.sep)
    'mem/abcde.zip'
    >>> str(root.parent)
    'mem'
    """

    __repr = "{self.__class__.__name__}({self.root.filename!r}, {self.at!r})"

    def __init__(self, root, at=""):
        """
        Construct a Path from a ZipFile or filename.

        Note: When the source is an existing ZipFile object,
        its type (__class__) will be mutated to a
        specialized type. If the caller wishes to retain the
        original type, the caller should either create a
        separate ZipFile object or pass a filename.
        """
        self.root = FastLookup.make(root)
        self.at = at

    def open(self, mode='r', *args, pwd=None, **kwargs):
        """
        Open this entry as text or binary following the semantics
        of ``pathlib.Path.open()`` by passing arguments through
        to io.TextIOWrapper().
        """
        if self.is_dir():
            raise IsADirectoryError(self)
        zip_mode = mode[0]
        if not self.exists() and zip_mode == 'r':
            raise FileNotFoundError(self)
        stream = self.root.open(self.at, zip_mode, pwd=pwd)
        if 'b' in mode:
            if args or kwargs:
                raise ValueError("encoding args invalid for binary operation")
            return stream
        return io.TextIOWrapper(stream, *args, **kwargs)

    @property
    def name(self):
        return pathlib.Path(self.at).name or self.filename.name

    @property
    def suffix(self):
        return pathlib.Path(self.at).suffix or self.filename.suffix

    @property
    def suffixes(self):
        return pathlib.Path(self.at).suffixes or self.filename.suffixes

    @property
    def stem(self):
        return pathlib.Path(self.at).stem or self.filename.stem

    @property
    def filename(self):
        return pathlib.Path(self.root.filename).joinpath(self.at)

    def read_text(self, *args, **kwargs):
        with self.open('r', *args, **kwargs) as strm:
            return strm.read()

    def read_bytes(self):
        with self.open('rb') as strm:
            return strm.read()

    def _is_child(self, path):
        return posixpath.dirname(path.at.rstrip("/")) == self.at.rstrip("/")

    def _next(self, at):
        return self.__class__(self.root, at)

    def is_dir(self):
        return not self.at or self.at.endswith("/")

    def is_file(self):
        return self.exists() and not self.is_dir()

    def exists(self):
        return self.at in self.root._name_set()

    def iterdir(self):
        if not self.is_dir():
            raise ValueError("Can't listdir a file")
        subs = map(self._next, self.root.namelist())
        return filter(self._is_child, subs)

    def __str__(self):
        return posixpath.join(self.root.filename, self.at)

    def __repr__(self):
        return self.__repr.format(self=self)

    def joinpath(self, *other):
        next = posixpath.join(self.at, *map(_pathlib_compat, other))
        return self._next(self.root.resolve_dir(next))

    __truediv__ = joinpath

    @property
    def parent(self):
        if not self.at:
            return self.filename.parent
        parent_at = posixpath.dirname(self.at.rstrip('/'))
        if parent_at:
            parent_at += '/'
        return self._next(parent_at)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/archive_util.py0000644000175100001730000001624314467657412020731 0ustar00runnerdocker"""Utilities for extracting common archive formats"""

import zipfile
import tarfile
import os
import shutil
import posixpath
import contextlib
from distutils.errors import DistutilsError

from ._path import ensure_directory

__all__ = [
    "unpack_archive",
    "unpack_zipfile",
    "unpack_tarfile",
    "default_filter",
    "UnrecognizedFormat",
    "extraction_drivers",
    "unpack_directory",
]


class UnrecognizedFormat(DistutilsError):
    """Couldn't recognize the archive type"""


def default_filter(src, dst):
    """The default progress/filter callback; returns True for all files"""
    return dst


def unpack_archive(filename, extract_dir, progress_filter=default_filter, drivers=None):
    """Unpack `filename` to `extract_dir`, or raise ``UnrecognizedFormat``

    `progress_filter` is a function taking two arguments: a source path
    internal to the archive ('/'-separated), and a filesystem path where it
    will be extracted.  The callback must return the desired extract path
    (which may be the same as the one passed in), or else ``None`` to skip
    that file or directory.  The callback can thus be used to report on the
    progress of the extraction, as well as to filter the items extracted or
    alter their extraction paths.

    `drivers`, if supplied, must be a non-empty sequence of functions with the
    same signature as this function (minus the `drivers` argument), that raise
    ``UnrecognizedFormat`` if they do not support extracting the designated
    archive type.  The `drivers` are tried in sequence until one is found that
    does not raise an error, or until all are exhausted (in which case
    ``UnrecognizedFormat`` is raised).  If you do not supply a sequence of
    drivers, the module's ``extraction_drivers`` constant will be used, which
    means that ``unpack_zipfile`` and ``unpack_tarfile`` will be tried, in that
    order.
    """
    for driver in drivers or extraction_drivers:
        try:
            driver(filename, extract_dir, progress_filter)
        except UnrecognizedFormat:
            continue
        else:
            return
    else:
        raise UnrecognizedFormat("Not a recognized archive type: %s" % filename)


def unpack_directory(filename, extract_dir, progress_filter=default_filter):
    """ "Unpack" a directory, using the same interface as for archives

    Raises ``UnrecognizedFormat`` if `filename` is not a directory
    """
    if not os.path.isdir(filename):
        raise UnrecognizedFormat("%s is not a directory" % filename)

    paths = {
        filename: ('', extract_dir),
    }
    for base, dirs, files in os.walk(filename):
        src, dst = paths[base]
        for d in dirs:
            paths[os.path.join(base, d)] = src + d + '/', os.path.join(dst, d)
        for f in files:
            target = os.path.join(dst, f)
            target = progress_filter(src + f, target)
            if not target:
                # skip non-files
                continue
            ensure_directory(target)
            f = os.path.join(base, f)
            shutil.copyfile(f, target)
            shutil.copystat(f, target)


def unpack_zipfile(filename, extract_dir, progress_filter=default_filter):
    """Unpack zip `filename` to `extract_dir`

    Raises ``UnrecognizedFormat`` if `filename` is not a zipfile (as determined
    by ``zipfile.is_zipfile()``).  See ``unpack_archive()`` for an explanation
    of the `progress_filter` argument.
    """

    if not zipfile.is_zipfile(filename):
        raise UnrecognizedFormat("%s is not a zip file" % (filename,))

    with zipfile.ZipFile(filename) as z:
        _unpack_zipfile_obj(z, extract_dir, progress_filter)


def _unpack_zipfile_obj(zipfile_obj, extract_dir, progress_filter=default_filter):
    """Internal/private API used by other parts of setuptools.
    Similar to ``unpack_zipfile``, but receives an already opened :obj:`zipfile.ZipFile`
    object instead of a filename.
    """
    for info in zipfile_obj.infolist():
        name = info.filename

        # don't extract absolute paths or ones with .. in them
        if name.startswith('/') or '..' in name.split('/'):
            continue

        target = os.path.join(extract_dir, *name.split('/'))
        target = progress_filter(name, target)
        if not target:
            continue
        if name.endswith('/'):
            # directory
            ensure_directory(target)
        else:
            # file
            ensure_directory(target)
            data = zipfile_obj.read(info.filename)
            with open(target, 'wb') as f:
                f.write(data)
        unix_attributes = info.external_attr >> 16
        if unix_attributes:
            os.chmod(target, unix_attributes)


def _resolve_tar_file_or_dir(tar_obj, tar_member_obj):
    """Resolve any links and extract link targets as normal files."""
    while tar_member_obj is not None and (
        tar_member_obj.islnk() or tar_member_obj.issym()
    ):
        linkpath = tar_member_obj.linkname
        if tar_member_obj.issym():
            base = posixpath.dirname(tar_member_obj.name)
            linkpath = posixpath.join(base, linkpath)
            linkpath = posixpath.normpath(linkpath)
        tar_member_obj = tar_obj._getmember(linkpath)

    is_file_or_dir = tar_member_obj is not None and (
        tar_member_obj.isfile() or tar_member_obj.isdir()
    )
    if is_file_or_dir:
        return tar_member_obj

    raise LookupError('Got unknown file type')


def _iter_open_tar(tar_obj, extract_dir, progress_filter):
    """Emit member-destination pairs from a tar archive."""
    # don't do any chowning!
    tar_obj.chown = lambda *args: None

    with contextlib.closing(tar_obj):
        for member in tar_obj:
            name = member.name
            # don't extract absolute paths or ones with .. in them
            if name.startswith('/') or '..' in name.split('/'):
                continue

            prelim_dst = os.path.join(extract_dir, *name.split('/'))

            try:
                member = _resolve_tar_file_or_dir(tar_obj, member)
            except LookupError:
                continue

            final_dst = progress_filter(name, prelim_dst)
            if not final_dst:
                continue

            if final_dst.endswith(os.sep):
                final_dst = final_dst[:-1]

            yield member, final_dst


def unpack_tarfile(filename, extract_dir, progress_filter=default_filter):
    """Unpack tar/tar.gz/tar.bz2 `filename` to `extract_dir`

    Raises ``UnrecognizedFormat`` if `filename` is not a tarfile (as determined
    by ``tarfile.open()``).  See ``unpack_archive()`` for an explanation
    of the `progress_filter` argument.
    """
    try:
        tarobj = tarfile.open(filename)
    except tarfile.TarError as e:
        raise UnrecognizedFormat(
            "%s is not a compressed or uncompressed tar file" % (filename,)
        ) from e

    for member, final_dst in _iter_open_tar(
        tarobj,
        extract_dir,
        progress_filter,
    ):
        try:
            # XXX Ugh
            tarobj._extract_member(member, final_dst)
        except tarfile.ExtractError:
            # chown/chmod/mkfifo/mknode/makedev failed
            pass

    return True


extraction_drivers = unpack_directory, unpack_zipfile, unpack_tarfile
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/build_meta.py0000644000175100001730000004717314467657412020366 0ustar00runnerdocker"""A PEP 517 interface to setuptools

Previously, when a user or a command line tool (let's call it a "frontend")
needed to make a request of setuptools to take a certain action, for
example, generating a list of installation requirements, the frontend would
would call "setup.py egg_info" or "setup.py bdist_wheel" on the command line.

PEP 517 defines a different method of interfacing with setuptools. Rather
than calling "setup.py" directly, the frontend should:

  1. Set the current directory to the directory with a setup.py file
  2. Import this module into a safe python interpreter (one in which
     setuptools can potentially set global variables or crash hard).
  3. Call one of the functions defined in PEP 517.

What each function does is defined in PEP 517. However, here is a "casual"
definition of the functions (this definition should not be relied on for
bug reports or API stability):

  - `build_wheel`: build a wheel in the folder and return the basename
  - `get_requires_for_build_wheel`: get the `setup_requires` to build
  - `prepare_metadata_for_build_wheel`: get the `install_requires`
  - `build_sdist`: build an sdist in the folder and return the basename
  - `get_requires_for_build_sdist`: get the `setup_requires` to build

Again, this is not a formal definition! Just a "taste" of the module.
"""

import io
import os
import shlex
import sys
import tokenize
import shutil
import contextlib
import tempfile
import warnings
from pathlib import Path
from typing import Dict, Iterator, List, Optional, Union

import setuptools
import distutils
from . import errors
from ._path import same_path
from ._reqs import parse_strings
from .warnings import SetuptoolsDeprecationWarning
from distutils.util import strtobool


__all__ = [
    'get_requires_for_build_sdist',
    'get_requires_for_build_wheel',
    'prepare_metadata_for_build_wheel',
    'build_wheel',
    'build_sdist',
    'get_requires_for_build_editable',
    'prepare_metadata_for_build_editable',
    'build_editable',
    '__legacy__',
    'SetupRequirementsError',
]

SETUPTOOLS_ENABLE_FEATURES = os.getenv("SETUPTOOLS_ENABLE_FEATURES", "").lower()
LEGACY_EDITABLE = "legacy-editable" in SETUPTOOLS_ENABLE_FEATURES.replace("_", "-")


class SetupRequirementsError(BaseException):
    def __init__(self, specifiers):
        self.specifiers = specifiers


class Distribution(setuptools.dist.Distribution):
    def fetch_build_eggs(self, specifiers):
        specifier_list = list(parse_strings(specifiers))

        raise SetupRequirementsError(specifier_list)

    @classmethod
    @contextlib.contextmanager
    def patch(cls):
        """
        Replace
        distutils.dist.Distribution with this class
        for the duration of this context.
        """
        orig = distutils.core.Distribution
        distutils.core.Distribution = cls
        try:
            yield
        finally:
            distutils.core.Distribution = orig


@contextlib.contextmanager
def no_install_setup_requires():
    """Temporarily disable installing setup_requires

    Under PEP 517, the backend reports build dependencies to the frontend,
    and the frontend is responsible for ensuring they're installed.
    So setuptools (acting as a backend) should not try to install them.
    """
    orig = setuptools._install_setup_requires
    setuptools._install_setup_requires = lambda attrs: None
    try:
        yield
    finally:
        setuptools._install_setup_requires = orig


def _get_immediate_subdirectories(a_dir):
    return [
        name for name in os.listdir(a_dir) if os.path.isdir(os.path.join(a_dir, name))
    ]


def _file_with_extension(directory, extension):
    matching = (f for f in os.listdir(directory) if f.endswith(extension))
    try:
        (file,) = matching
    except ValueError:
        raise ValueError(
            'No distribution was found. Ensure that `setup.py` '
            'is not empty and that it calls `setup()`.'
        )
    return file


def _open_setup_script(setup_script):
    if not os.path.exists(setup_script):
        # Supply a default setup.py
        return io.StringIO(u"from setuptools import setup; setup()")

    return getattr(tokenize, 'open', open)(setup_script)


@contextlib.contextmanager
def suppress_known_deprecation():
    with warnings.catch_warnings():
        warnings.filterwarnings('ignore', 'setup.py install is deprecated')
        yield


_ConfigSettings = Optional[Dict[str, Union[str, List[str], None]]]
"""
Currently the user can run::

    pip install -e . --config-settings key=value
    python -m build -C--key=value -C key=value

- pip will pass both key and value as strings and overwriting repeated keys
  (pypa/pip#11059).
- build will accumulate values associated with repeated keys in a list.
  It will also accept keys with no associated value.
  This means that an option passed by build can be ``str | list[str] | None``.
- PEP 517 specifies that ``config_settings`` is an optional dict.
"""


class _ConfigSettingsTranslator:
    """Translate ``config_settings`` into distutils-style command arguments.
    Only a limited number of options is currently supported.
    """

    # See pypa/setuptools#1928 pypa/setuptools#2491

    def _get_config(self, key: str, config_settings: _ConfigSettings) -> List[str]:
        """
        Get the value of a specific key in ``config_settings`` as a list of strings.

        >>> fn = _ConfigSettingsTranslator()._get_config
        >>> fn("--global-option", None)
        []
        >>> fn("--global-option", {})
        []
        >>> fn("--global-option", {'--global-option': 'foo'})
        ['foo']
        >>> fn("--global-option", {'--global-option': ['foo']})
        ['foo']
        >>> fn("--global-option", {'--global-option': 'foo'})
        ['foo']
        >>> fn("--global-option", {'--global-option': 'foo bar'})
        ['foo', 'bar']
        """
        cfg = config_settings or {}
        opts = cfg.get(key) or []
        return shlex.split(opts) if isinstance(opts, str) else opts

    def _valid_global_options(self):
        """Global options accepted by setuptools (e.g. quiet or verbose)."""
        options = (opt[:2] for opt in setuptools.dist.Distribution.global_options)
        return {flag for long_and_short in options for flag in long_and_short if flag}

    def _global_args(self, config_settings: _ConfigSettings) -> Iterator[str]:
        """
        Let the user specify ``verbose`` or ``quiet`` + escape hatch via
        ``--global-option``.
        Note: ``-v``, ``-vv``, ``-vvv`` have similar effects in setuptools,
        so we just have to cover the basic scenario ``-v``.

        >>> fn = _ConfigSettingsTranslator()._global_args
        >>> list(fn(None))
        []
        >>> list(fn({"verbose": "False"}))
        ['-q']
        >>> list(fn({"verbose": "1"}))
        ['-v']
        >>> list(fn({"--verbose": None}))
        ['-v']
        >>> list(fn({"verbose": "true", "--global-option": "-q --no-user-cfg"}))
        ['-v', '-q', '--no-user-cfg']
        >>> list(fn({"--quiet": None}))
        ['-q']
        """
        cfg = config_settings or {}
        falsey = {"false", "no", "0", "off"}
        if "verbose" in cfg or "--verbose" in cfg:
            level = str(cfg.get("verbose") or cfg.get("--verbose") or "1")
            yield ("-q" if level.lower() in falsey else "-v")
        if "quiet" in cfg or "--quiet" in cfg:
            level = str(cfg.get("quiet") or cfg.get("--quiet") or "1")
            yield ("-v" if level.lower() in falsey else "-q")

        valid = self._valid_global_options()
        args = self._get_config("--global-option", config_settings)
        yield from (arg for arg in args if arg.strip("-") in valid)

    def __dist_info_args(self, config_settings: _ConfigSettings) -> Iterator[str]:
        """
        The ``dist_info`` command accepts ``tag-date`` and ``tag-build``.

        .. warning::
           We cannot use this yet as it requires the ``sdist`` and ``bdist_wheel``
           commands run in ``build_sdist`` and ``build_wheel`` to reuse the egg-info
           directory created in ``prepare_metadata_for_build_wheel``.

        >>> fn = _ConfigSettingsTranslator()._ConfigSettingsTranslator__dist_info_args
        >>> list(fn(None))
        []
        >>> list(fn({"tag-date": "False"}))
        ['--no-date']
        >>> list(fn({"tag-date": None}))
        ['--no-date']
        >>> list(fn({"tag-date": "true", "tag-build": ".a"}))
        ['--tag-date', '--tag-build', '.a']
        """
        cfg = config_settings or {}
        if "tag-date" in cfg:
            val = strtobool(str(cfg["tag-date"] or "false"))
            yield ("--tag-date" if val else "--no-date")
        if "tag-build" in cfg:
            yield from ["--tag-build", str(cfg["tag-build"])]

    def _editable_args(self, config_settings: _ConfigSettings) -> Iterator[str]:
        """
        The ``editable_wheel`` command accepts ``editable-mode=strict``.

        >>> fn = _ConfigSettingsTranslator()._editable_args
        >>> list(fn(None))
        []
        >>> list(fn({"editable-mode": "strict"}))
        ['--mode', 'strict']
        """
        cfg = config_settings or {}
        mode = cfg.get("editable-mode") or cfg.get("editable_mode")
        if not mode:
            return
        yield from ["--mode", str(mode)]

    def _arbitrary_args(self, config_settings: _ConfigSettings) -> Iterator[str]:
        """
        Users may expect to pass arbitrary lists of arguments to a command
        via "--global-option" (example provided in PEP 517 of a "escape hatch").

        >>> fn = _ConfigSettingsTranslator()._arbitrary_args
        >>> list(fn(None))
        []
        >>> list(fn({}))
        []
        >>> list(fn({'--build-option': 'foo'}))
        ['foo']
        >>> list(fn({'--build-option': ['foo']}))
        ['foo']
        >>> list(fn({'--build-option': 'foo'}))
        ['foo']
        >>> list(fn({'--build-option': 'foo bar'}))
        ['foo', 'bar']
        >>> warnings.simplefilter('error', SetuptoolsDeprecationWarning)
        >>> list(fn({'--global-option': 'foo'}))  # doctest: +IGNORE_EXCEPTION_DETAIL
        Traceback (most recent call last):
        SetuptoolsDeprecationWarning: ...arguments given via `--global-option`...
        """
        args = self._get_config("--global-option", config_settings)
        global_opts = self._valid_global_options()
        bad_args = []

        for arg in args:
            if arg.strip("-") not in global_opts:
                bad_args.append(arg)
                yield arg

        yield from self._get_config("--build-option", config_settings)

        if bad_args:
            SetuptoolsDeprecationWarning.emit(
                "Incompatible `config_settings` passed to build backend.",
                f"""
                The arguments {bad_args!r} were given via `--global-option`.
                Please use `--build-option` instead,
                `--global-option` is reserved for flags like `--verbose` or `--quiet`.
                """,
                due_date=(2023, 9, 26),  # Warning introduced in v64.0.1, 11/Aug/2022.
            )


class _BuildMetaBackend(_ConfigSettingsTranslator):
    def _get_build_requires(self, config_settings, requirements):
        sys.argv = [
            *sys.argv[:1],
            *self._global_args(config_settings),
            "egg_info",
            *self._arbitrary_args(config_settings),
        ]
        try:
            with Distribution.patch():
                self.run_setup()
        except SetupRequirementsError as e:
            requirements += e.specifiers

        return requirements

    def run_setup(self, setup_script='setup.py'):
        # Note that we can reuse our build directory between calls
        # Correctness comes first, then optimization later
        __file__ = os.path.abspath(setup_script)
        __name__ = '__main__'

        with _open_setup_script(__file__) as f:
            code = f.read().replace(r'\r\n', r'\n')

        try:
            exec(code, locals())
        except SystemExit as e:
            if e.code:
                raise
            # We ignore exit code indicating success
            SetuptoolsDeprecationWarning.emit(
                "Running `setup.py` directly as CLI tool is deprecated.",
                "Please avoid using `sys.exit(0)` or similar statements "
                "that don't fit in the paradigm of a configuration file.",
                see_url="https://blog.ganssle.io/articles/2021/10/"
                "setup-py-deprecated.html",
            )

    def get_requires_for_build_wheel(self, config_settings=None):
        return self._get_build_requires(config_settings, requirements=['wheel'])

    def get_requires_for_build_sdist(self, config_settings=None):
        return self._get_build_requires(config_settings, requirements=[])

    def _bubble_up_info_directory(self, metadata_directory: str, suffix: str) -> str:
        """
        PEP 517 requires that the .dist-info directory be placed in the
        metadata_directory. To comply, we MUST copy the directory to the root.

        Returns the basename of the info directory, e.g. `proj-0.0.0.dist-info`.
        """
        info_dir = self._find_info_directory(metadata_directory, suffix)
        if not same_path(info_dir.parent, metadata_directory):
            shutil.move(str(info_dir), metadata_directory)
            # PEP 517 allow other files and dirs to exist in metadata_directory
        return info_dir.name

    def _find_info_directory(self, metadata_directory: str, suffix: str) -> Path:
        for parent, dirs, _ in os.walk(metadata_directory):
            candidates = [f for f in dirs if f.endswith(suffix)]

            if len(candidates) != 0 or len(dirs) != 1:
                assert len(candidates) == 1, f"Multiple {suffix} directories found"
                return Path(parent, candidates[0])

        msg = f"No {suffix} directory found in {metadata_directory}"
        raise errors.InternalError(msg)

    def prepare_metadata_for_build_wheel(
        self, metadata_directory, config_settings=None
    ):
        sys.argv = [
            *sys.argv[:1],
            *self._global_args(config_settings),
            "dist_info",
            "--output-dir",
            metadata_directory,
            "--keep-egg-info",
        ]
        with no_install_setup_requires():
            self.run_setup()

        self._bubble_up_info_directory(metadata_directory, ".egg-info")
        return self._bubble_up_info_directory(metadata_directory, ".dist-info")

    def _build_with_temp_dir(
        self, setup_command, result_extension, result_directory, config_settings
    ):
        result_directory = os.path.abspath(result_directory)

        # Build in a temporary directory, then copy to the target.
        os.makedirs(result_directory, exist_ok=True)
        temp_opts = {"prefix": ".tmp-", "dir": result_directory}
        with tempfile.TemporaryDirectory(**temp_opts) as tmp_dist_dir:
            sys.argv = [
                *sys.argv[:1],
                *self._global_args(config_settings),
                *setup_command,
                "--dist-dir",
                tmp_dist_dir,
                *self._arbitrary_args(config_settings),
            ]
            with no_install_setup_requires():
                self.run_setup()

            result_basename = _file_with_extension(tmp_dist_dir, result_extension)
            result_path = os.path.join(result_directory, result_basename)
            if os.path.exists(result_path):
                # os.rename will fail overwriting on non-Unix.
                os.remove(result_path)
            os.rename(os.path.join(tmp_dist_dir, result_basename), result_path)

        return result_basename

    def build_wheel(
        self, wheel_directory, config_settings=None, metadata_directory=None
    ):
        with suppress_known_deprecation():
            return self._build_with_temp_dir(
                ['bdist_wheel'], '.whl', wheel_directory, config_settings
            )

    def build_sdist(self, sdist_directory, config_settings=None):
        return self._build_with_temp_dir(
            ['sdist', '--formats', 'gztar'], '.tar.gz', sdist_directory, config_settings
        )

    def _get_dist_info_dir(self, metadata_directory: Optional[str]) -> Optional[str]:
        if not metadata_directory:
            return None
        dist_info_candidates = list(Path(metadata_directory).glob("*.dist-info"))
        assert len(dist_info_candidates) <= 1
        return str(dist_info_candidates[0]) if dist_info_candidates else None

    if not LEGACY_EDITABLE:
        # PEP660 hooks:
        # build_editable
        # get_requires_for_build_editable
        # prepare_metadata_for_build_editable
        def build_editable(
            self, wheel_directory, config_settings=None, metadata_directory=None
        ):
            # XXX can or should we hide our editable_wheel command normally?
            info_dir = self._get_dist_info_dir(metadata_directory)
            opts = ["--dist-info-dir", info_dir] if info_dir else []
            cmd = ["editable_wheel", *opts, *self._editable_args(config_settings)]
            with suppress_known_deprecation():
                return self._build_with_temp_dir(
                    cmd, ".whl", wheel_directory, config_settings
                )

        def get_requires_for_build_editable(self, config_settings=None):
            return self.get_requires_for_build_wheel(config_settings)

        def prepare_metadata_for_build_editable(
            self, metadata_directory, config_settings=None
        ):
            return self.prepare_metadata_for_build_wheel(
                metadata_directory, config_settings
            )


class _BuildMetaLegacyBackend(_BuildMetaBackend):
    """Compatibility backend for setuptools

    This is a version of setuptools.build_meta that endeavors
    to maintain backwards
    compatibility with pre-PEP 517 modes of invocation. It
    exists as a temporary
    bridge between the old packaging mechanism and the new
    packaging mechanism,
    and will eventually be removed.
    """

    def run_setup(self, setup_script='setup.py'):
        # In order to maintain compatibility with scripts assuming that
        # the setup.py script is in a directory on the PYTHONPATH, inject
        # '' into sys.path. (pypa/setuptools#1642)
        sys_path = list(sys.path)  # Save the original path

        script_dir = os.path.dirname(os.path.abspath(setup_script))
        if script_dir not in sys.path:
            sys.path.insert(0, script_dir)

        # Some setup.py scripts (e.g. in pygame and numpy) use sys.argv[0] to
        # get the directory of the source code. They expect it to refer to the
        # setup.py script.
        sys_argv_0 = sys.argv[0]
        sys.argv[0] = setup_script

        try:
            super(_BuildMetaLegacyBackend, self).run_setup(setup_script=setup_script)
        finally:
            # While PEP 517 frontends should be calling each hook in a fresh
            # subprocess according to the standard (and thus it should not be
            # strictly necessary to restore the old sys.path), we'll restore
            # the original path so that the path manipulation does not persist
            # within the hook after run_setup is called.
            sys.path[:] = sys_path
            sys.argv[0] = sys_argv_0


# The primary backend
_BACKEND = _BuildMetaBackend()

get_requires_for_build_wheel = _BACKEND.get_requires_for_build_wheel
get_requires_for_build_sdist = _BACKEND.get_requires_for_build_sdist
prepare_metadata_for_build_wheel = _BACKEND.prepare_metadata_for_build_wheel
build_wheel = _BACKEND.build_wheel
build_sdist = _BACKEND.build_sdist

if not LEGACY_EDITABLE:
    get_requires_for_build_editable = _BACKEND.get_requires_for_build_editable
    prepare_metadata_for_build_editable = _BACKEND.prepare_metadata_for_build_editable
    build_editable = _BACKEND.build_editable


# The legacy backend
__legacy__ = _BuildMetaLegacyBackend()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/cli-32.exe0000644000175100001730000002700014467657412017366 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$z
2dadadacadasee`daseadasea`dase``daseg`dace`daeadad``dadadadf`daRichdaPEL'hd$0@p@6P`22@0.text `.rdata
0@@.data@(@.rsrcP*@@.reloc`,@BC@U}u@@t	jP0@]UEPjuup01@]Ujuu]US]VWKCu+j]Px0@ȃM3"q3ɉM~SU<\uG&<"u ~Wj\VMU3\F3AFM;|…~Wj\VtE_f"^[]U@@3ʼnEEEhPj0@jhjjjhP0@jhQP0@QAu+ʍ;v8.tH;w퍍IfAIu1@1@Af1@fA1@WA
jPu2Ph1@j0@PG_M3]VhPWWH@;st

t
ujh1@P1@t&1@~1@1@fօ΍QAuS+jQx0@3ۉQ1@tDFFP1@uFP1@ttm\uCƀ"u0Ãu
339EȈtSj\W3ۊoGgtSj\W3ۋ@G;NJt@/u\u5h0@PPPPWփ\PPPPP֍QAu+ʊ

Ӏ\uQ3\\tf;r	H8\ujWPPPl0@=x0@jh׋hPV1@(,x0@jhhWV1@=x0@u/3h1@j0@PrF[^_M3Q]Ëj
AP׋V~{9~*4RC;|勵P39~/4C;|勵}t@V0@Vh1@j0@Pl[^_M3I]Ë΍QAu+ʺy;~0󐋅Y@Au+GB;|ߋx0@jWVh1@PNFu+;~O@ff4h1@PdQDAu+FG;|WDžjh@DžDffffffff0@PPjjjjjjj0@u,hP1@j0@P3[^_M3]Ëj@@0@P0@u,hl1@j0@Pv3[^_M3V]ËM3[^_?]UEPjujupQ0@H];
@@uyVjvVPDj0^tslh"@nP>YYuQcth@Y)$PGYt
Tuj-3PYjh5@/jYP2ۈ]eEܡtV9Yt6WjW1@G9>tVYt6$
Y		0	WV0q.tku	jj{YYE5MEQP{	YYËet2}u	EEMd
Y_^[jVj	uh	tUjD0@uH0@h	@0@P<0@]U$j80@tjY) A@
A@A@A@5A@=A@f8A@f
,A@fA@fA@f%A@f-@@0A@E$A@E(A@E4A@p@@(A@,@@ @@	$@@0@@jXkǀ4@@jXk
@@LjX
@@Lh2@UEVH<AQAk(;tM;Jr
BB;r(;u3^]ËVt d@C@P;t3u2^ð^U}uDC@vru2]eu
jZY]U=EC@t]Vutubt&u"hHC@YuhTC@yYt+20
HC@
LC@
PC@
TC@
XC@
\C@EC@^]j/jh6@KeMZf9@u]<@@PEuLf9@u>E@+PQ|YYt'x$|!EE3Ɂ8ËeE2Md
Y_^[Ut}u	3@C@]U=DC@t}uuuYY]U=HC@uuThHC@BYY#E]UuYH]UeEeP(0@E3EE,0@1E00@1EEP40@EM3E3E3Ë
@@VWN@;tu&;uO@u

Gȉ
@@_
@@^33@ø@h`C@$0@ðhhjguj?hC@H$HHH39@@øC@øC@U$Sj80@tM)j$jPF|xffftfpflfhEEDž@jPEjPEE@EE 0@jXۍEEۉED0@EPH0@uujY[ejL0@t3MZf9u)H<ȁ9PEuf9Auytv2h!@D0@UVW}7>csmu%~uF= t=!t="t=@t_3^]0w0\̃%pC@SV5@5@;sW>t
1@׃;r_^[SV5@5@;sW>t
1@׃;r_^[h"@d5D$l$l$+SVW@@1E3PeuEEEEdUVu6uuuVh2@h@@^]U%tC@$
@@j
80@e3SVW3ɍ}S[wO3ɉWE܋}EGenuE5ineIEE5ntelE3@S[]܉EEljsKSuCE%?=t#=`t=pt=Pt=`t=pu=xC@=xC@=xC@MjXM9E|03S[]܉sKMS]t=xC@]@@tC@@@tC@@@tytq3ЉEUEMj^#;uW@@tC@@@ t; tC@@@#;uEM#;u

@@@5tC@_^[339@@%T0@%X0@%`0@%\0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%1@%0@%0@%0@%0@%t0@%0@%0@%0@%0@%0@%0@%0@%0@%0@UQ=tC@|f}t	}uT]E?t?uét*uéué uøËE8"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999@@@@@failed to create process.
failed to get exit code from process.
%s %s-script.pyCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %s @@p@@@@3@1@3@ 1@'hd
l`3`"3,H3"(##$$$$c$k$@"N%x.text$mn0.idata$51.00cfg$1.CRT$XCA(1.CRT$XCAA,1.CRT$XCZ01.CRT$XIA41.CRT$XIAA81.CRT$XIAC<1.CRT$XIZ@1.CRT$XPAD1.CRT$XPZH1.CRT$XTAL1.CRT$XTZP1.rdata3.rdata$sxdata3\.rdata$voltmd`3l.rdata$zzzdbg5.rtc$IAA5.rtc$IZZ5.rtc$TAA5.rtc$TZZ5<.xdata$x6.idata$26.idata$36.idata$48.idata$6@.data@x.bssP`.rsrc$01`P.rsrc$02,@@@N@a@680L7,9T0l7;t0`7;h07;07<084<17V<0x7v<07<08"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999CreateFileAdGetFinalPathNameByHandleAWaitForSingleObjectQGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dllHmemset__current_exception__current_exception_context5_except_handler4_commonVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspaceB_seh_filter_exeD_set_app_type.__setusermatherr_configure_narrow_argv5_initialize_narrow_environment*_get_initial_narrow_environment8_initterm9_initterm_eXexit%_exitT_set_fmode_cexit_c_exit?_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode6_initialize_onexit_table>_register_onexit_function_crt_atexit_controlfp_sjterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllUnhandledExceptionFilterSetUnhandledExceptionFilter,GetCurrentProcessTerminateProcessIsProcessorFeaturePresentmQueryPerformanceCounter-GetCurrentProcessId1GetCurrentThreadIdGetSystemTimeAsFileTimeInitializeSListHeadIsDebuggerPresentGetModuleHandleWDN@0	H`P}

  
    
      
        
      
    
  

00'0[00J1u1111222<2D222222303H3j3)4<4s4M5S5w555555666>7I777(8P8Y8a888888!949x99:3:H:M:R:s:x:::;;;;;;;;;;;;<<<<<#<+<3<;>> >*>>>>>?'?0?=?S?????? 000%0011;1z11111122*2A2^222222u3~33333333+444=4K4T4v4}4444444444444444444455555 5&5,52585>5D5J5T50(1(1418122L2P2X2225566././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/cli-64.exe0000644000175100001730000003400014467657412017371 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$bc1c1c161c10c1X1c10c10c10c10c1c1c10c1Z1c10c1Richc1PEd'hd"$"@@`:p`053@0P.text `.rdata,0@@.dataHP0@.pdata`2@@.rsrcp4@@.reloc06@BH)FH(u
"@t3 H(HT$LD$LL$ SVWH0HHt$`HE3Ht$ LHH!H0_^[E38H\$Hl$Ht$H|$ ATAVAWH HLHDH<u, 3LA?L3H3!tKH"!u3H@ta@	!ttO@\u@"u׃u	33EtLDz\I$L3@tA6I딅tLDz\IL3AIIcAAMt@t,y tDKHc u;8H\$@IHl$HHt$PH|$XH A_A^A\H\$Hl$Ht$H|$ AVH HHHǀ<9u?HcH3HcL"HX~X<\u&<"u ~\DHH3\H3HƈHHu~\DHHHl$8IHt$@H|$Hf"H\$0H A^@UVWATH$HHH=H3H DD$dDHT$xAL$`HU33HMHt$0E3D$(D$ DFE3HUHAHMHH@84uHMHHMH;v8.t@0HMHH;wHM@0Hf@8qHIu3ufApA
HM\u$H"HLEHLGGH$HL$8AL$0HcHHًHHDHH;st

t
uA@0HHt)HT$XHLHHtLH/uA\uHHLHD$ LHT$P@8t$P\HLHD$ LHT$PHMHH@8tH@uDHA\uDAHAHEA\t!ffHH;r@0HȀ8\uLHt$ LHT$PH(HHAHL"Mu(IAOLH6HAGW|$XL$@AE3LcHD$pA"Hx~lE3fBD5<\u(<"u!~ٲ\DH{HA\HABD5IƈHM;|Ll$h~ٲ\DH?HE3HD$pf"Hc|$`HHH~%Ld$xIwHHHH;||$dL6t5HT$XIMMHHsHfHA<uLd$XI~-AfKHDH<uIM;|HcɺMHHHHHA<uI~FfffMHHcHJIHH<uHI;|WDt$P3EhWHEH
KEEPMMMMMMCHEE3HD$HE3HEHHD$@3Lt$8Lt$0Dt$(D$ uHHHJEHM6HMHT$PuHHH}Dt$PAL$@L$8H$L$0H H3HHA\_^]HT$LD$LL$ SVWH0HHt$`H
LHt$(HHD$ LHHHHH0_^[H(MA8HI
H(@SEHALALtA@McPLHcL#IcJHCHHCDtDLL3I[ffH;
A5uHfuH@SH Dts7	H
l	uRtH
~mjtUPuH [ùH(_3H(H(7H(MH\$Ht$WH0/6@2@t$ ؋
9#uJ9HH

t
H_H
H
q9@@t$ HH8tHntE3AP3HHH8tHBtHT

H	H	LHӋtU@u
3ұt;|$ u	H\$@Ht$HH0_ù		H(H(r@SH H3HHȺ	H [H%HL$H8t)H
B3HD$8H)4HD$8HH3H4H2HD$@H3]2	W2a2HkH
Y2HHkH
1HL HkH
1HL H
XH8@SVWH@HCH3E3HT$`HHt9Hd$8HL$hHT$`LHL$0LHL$pHL$(3H\$ ǃ|H@_^[H(t!eH%0HHH;t3H
6u2H(ð@SH 6ɻDÈ6u2u	3H [@SH =l6ugwjt(u$H
V6uH
^6t.23foH%6H.6.6H766H [ù^HLMZf9	uxHc
=Z=p=====AAB"B@BTBCBBBBBBhBA==>(>"Cb>n> @X>
@?@@@\@?@???|>?n?>>??L?2?x@?@?>>>@0@@>>>!@!@`'@'@'@D'@@@@failed to create process.
failed to get exit code from process.
%s %s-script.pyCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %sPP@P@@P@P2@`2@5@X2@h2@p2@x2@2@'hd
5!5,5/D "#%&N&
'6P.text$mnP'6.text$mn$00'6.text$x0P.idata$5P28.00cfg2.CRT$XCA2.CRT$XCAA2.CRT$XCZ2.CRT$XIA2.CRT$XIAA2.CRT$XIAC2.CRT$XIZ2.CRT$XPA2.CRT$XPZ2.CRT$XTA2.CRT$XTZ2.rdata5\.rdata$voltmd5.rdata$zzzdbg`8.rtc$IAAh8.rtc$IZZp8.rtc$TAAx8.rtc$TZZ8.xdata:.idata$2:.idata$3:P.idata$40=.idata$6P@.data@P.bss`.pdatap`.rsrc$01`p.rsrc$02Rp`0
t	dT42td
T	42B&p`P0 !''48!L8!L8!8020	d	4Rp&'&8'2P		brp`0	"&u 'u P

4

RP4P

4
2pd4p:=0;F>0;@1;@00<@P1<A1=>A02<`A01<A 1 <A@10=>=Z=p=====AAB"B@BTBCBBBBBBhBA==>(>"Cb>n> @X>
@?@@@\@?@???|>?n?>>??L?2?x@?@?>>>@0@@>>>CreateFileAkGetFinalPathNameByHandleAWaitForSingleObjectXGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dll>memset__C_specific_handler__current_exception__current_exception_contextVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspace@_seh_filter_exeB_set_app_type	__setusermatherr_configure_narrow_argv3_initialize_narrow_environment(_get_initial_narrow_environment6_initterm7_initterm_eUexit#_exitT_set_fmode_cexit_c_exit=_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode4_initialize_onexit_table<_register_onexit_function_crt_atexitgterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllRtlCaptureContextRtlLookupFunctionEntryRtlVirtualUnwindUnhandledExceptionFilterSetUnhandledExceptionFilter2GetCurrentProcessTerminateProcessIsProcessorFeaturePresentpQueryPerformanceCounter3GetCurrentProcessId7GetCurrentThreadId
GetSystemTimeAsFileTimeInitializeSListHeadIsDebuggerPresentGetModuleHandleW<memcpy] f2-+48@8888L8L89 9.80M8P0989<988@D9@R8T<9Z9\9	8U<9X<9| 9|  <9  <9 !<9!!8 !!9""8@"#9##8#S$9T$$9$$9$x&9`'b'9'':''|9''90	H`p}

  
    
      
        
      
    
  

00PX`hp(@HФ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/cli-arm64.exe0000644000175100001730000003300014467657412020070 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$b1111101x11010101011101z1101Rich1PEd'hd"$@`8p` $4p3@0.text4 `.rdata0@@.dataP.@.pdata `0@@.rsrcp2@@.reloc$4@BC11@c1_1@1@c0TC_ {C{A_0"@AT_{0"11@1@G!> (_{5(!@4@R? R{_S{@@?{@SŨ_S[c{i9*i4	85	qT"Q@i9i4I85IK) !Q5i@!|@Q?a&i9"4	85"˟q-T†@3rɂ_*9	j4
85	KQU5{cB[ASè_RS[ck#{i9i4	85i@?@`9RR?4`8(@?֠5t84h@*?@44rqaTqTraT_qq~4*RrB6R484*RhB6R8(({(4`9(@?4`8@?֠5h9H5{#@kCcB[ASŨ_S[c{i9i4	85˨z
i@!?XRR9qTRh9qqaTqaTqT*R$B6R8Rh8Q8u5qT*RB6y{@cB[ASĨ_{S[ck+@** R?@RdR"RR?@R R?9i4	85		(	)T
9_qT9	HT99j4*85R*9)
8*i(85R*1aT@@R?@R 
*
 *
T	9?q$Jz$Mz!T9AB
? 4	!(@W(	@(19
9S
@9)4R?qATj9	9I5Y@C?C9h59qqTY@C?9i4	85		*H	9?qqTI8H	?qqT	T9
8_qqaT]@C?i@!Ҁ ?i@!Ҁ ?@ ?֗@@R@?a!@R|@ҺH@i@?6# q-T#xQ`@Q5"q
Ts"Q`@Q54@?@@R?
@RG*O!R=OAAAa
RCa@?@R$R?@5@@R?A
R3@(	!	@@?
@@S?@5@@R?
R@f+@kDcC[BSA{ƨ_S{~@@@?qZ{@SŨ_#{h@	~(ia(!L R{#_#{ R* RS42!k54	}SH4{5{A#_R>#{R{#_#{{#_#S{ RSH4RC9iS3h*@q
Th5(Rh*	!	N`4RB	CHRh*5RC9*h@SH4h@AR1
A ??th@Sh4`@8@@E*iS(4U5#R R*	*^S4C@9H5*{¨@S¨#_RMRK**>#{{#_#{4	@(
?`TH_hIȱ5;(R{#_ R#{)(@9q(9Sh5RS5R R{#_#S{3hA9*h5qT4t5(5(A4R
(		%		(A	%		(Rh9 R{S#_֠R>#{IRh@y	kTh=@j(	RH@	k!TH1@y-qTH)@y
aI
@y
+!
@T

@A*T		@)
A)ThR
%@h6R RRR{¨#_#{S145ȿ;{A#_#{@9S)SH45*c*a R{A#_#{	(@aTY Rq`{A#_#{Z{#_#S{h@XT)@c?@%@?@	|@(!@?@	|@(-@?@#@		@)C(	@?Xh(	{èS#_ 2-+3-+R_ R_R_1@__#{	@(@{#_@q_A_!_`>_#{9@?֠@yIR	k!T<@	R
(H@	kaTH1@y-qTH@9qTH@qR{#_!5@#S{@h@	kTh@q!Ti"@(K	q)TH?kTR{S#_Q@Q> csm @#S{	(!3!BTh@1
A ??T{S#_#S{	(!3!BTh@1
A ??T{S#_C@R`>C_@q_F@B@J@N@@@@@z@@@@@@@@@@@@r@f@@@@@@@@@R@#{(@@ {#_a#{@	@?k{#_a;;;;<<.<F<^@t@@D@@@@z<p<<<@<<><>=?>H>R>\>==>>>2>?<
=*>==|=>D=?,?$?*==>:>r=h=^="@@&@8@X@@failed to create process.
failed to get exit code from process.
%s %s-script.pyCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %sP@0Q@@P@2@2@ 2@(2@'hd
h5!.text.text$mn&d.text$x0.idata$52 .00cfg02.CRT$XCA82.CRT$XCAA@2.CRT$XCZH2.CRT$XIAP2.CRT$XIAAX2.CRT$XIAC`2.CRT$XIZh2.CRT$XPAp2.CRT$XPZx2.CRT$XTA2.CRT$XTZ2p.rdata5h.rdata$zzzdbgh7.rtc$IAAp7.rtc$IZZx7.rtc$TAA7.rtc$TZZ78.xdata8.idata$29.idata$39.idata$4;F.idata$6P .data P.bss` .pdatap`.rsrc$01`p.rsrc$02`"Ђ*Ђ*`"Ђ*Ђ*^0 
ɈȄ@@@@BB/@(@kP]@Ђ$h%&&@@@5ph%\ '\ 
@@@*@#@"%@@"9b<0 :<0h:6?0P:V?0:|?1H;?1;?1:?0:@0:"@1;;;;<<.<F<^@t@@D@@@@z<p<<<@<<><>=?>H>R>\>==>>>2>?<
=*>==|=>D=?,?$?*==>:>r=h=^=CreateFileAiGetFinalPathNameByHandleAWaitForSingleObjectVGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dll=memset__C_specific_handler__current_exception__current_exception_contextVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspace@_seh_filter_exeB_set_app_type	__setusermatherr_configure_narrow_argv3_initialize_narrow_environment(_get_initial_narrow_environment6_initterm7_initterm_eUexit#_exitT_set_fmode_cexit_c_exit=_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode4_initialize_onexit_table<_register_onexit_function_crt_atexitgterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllkQueryPerformanceCounter2GetCurrentProcessId6GetCurrentThreadIdGetSystemTimeAsFileTimeInitializeSListHeadSetUnhandledExceptionFilterGetModuleHandleW;memcpy] f2-+7 7P7pL8X8857p%fi0077=X7!8%`8!08a8`8p AA MA!QAP!%x!B"=0##8`$eB$eB0%&@8'80	H`p}

  
    
      
        
      
    
  

0$(8PXX`ȣ裠././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/cli.exe0000644000175100001730000002700014467657412017144 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$z
2dadadacadasee`daseadasea`dase``daseg`dace`daeadad``dadadadf`daRichdaPEL'hd$0@p@6P`22@0.text `.rdata
0@@.data@(@.rsrcP*@@.reloc`,@BC@U}u@@t	jP0@]UEPjuup01@]Ujuu]US]VWKCu+j]Px0@ȃM3"q3ɉM~SU<\uG&<"u ~Wj\VMU3\F3AFM;|…~Wj\VtE_f"^[]U@@3ʼnEEEhPj0@jhjjjhP0@jhQP0@QAu+ʍ;v8.tH;w퍍IfAIu1@1@Af1@fA1@WA
jPu2Ph1@j0@PG_M3]VhPWWH@;st

t
ujh1@P1@t&1@~1@1@fօ΍QAuS+jQx0@3ۉQ1@tDFFP1@uFP1@ttm\uCƀ"u0Ãu
339EȈtSj\W3ۊoGgtSj\W3ۋ@G;NJt@/u\u5h0@PPPPWփ\PPPPP֍QAu+ʊ

Ӏ\uQ3\\tf;r	H8\ujWPPPl0@=x0@jh׋hPV1@(,x0@jhhWV1@=x0@u/3h1@j0@PrF[^_M3Q]Ëj
AP׋V~{9~*4RC;|勵P39~/4C;|勵}t@V0@Vh1@j0@Pl[^_M3I]Ë΍QAu+ʺy;~0󐋅Y@Au+GB;|ߋx0@jWVh1@PNFu+;~O@ff4h1@PdQDAu+FG;|WDžjh@DžDffffffff0@PPjjjjjjj0@u,hP1@j0@P3[^_M3]Ëj@@0@P0@u,hl1@j0@Pv3[^_M3V]ËM3[^_?]UEPjujupQ0@H];
@@uyVjvVPDj0^tslh"@nP>YYuQcth@Y)$PGYt
Tuj-3PYjh5@/jYP2ۈ]eEܡtV9Yt6WjW1@G9>tVYt6$
Y		0	WV0q.tku	jj{YYE5MEQP{	YYËet2}u	EEMd
Y_^[jVj	uh	tUjD0@uH0@h	@0@P<0@]U$j80@tjY) A@
A@A@A@5A@=A@f8A@f
,A@fA@fA@f%A@f-@@0A@E$A@E(A@E4A@p@@(A@,@@ @@	$@@0@@jXkǀ4@@jXk
@@LjX
@@Lh2@UEVH<AQAk(;tM;Jr
BB;r(;u3^]ËVt d@C@P;t3u2^ð^U}uDC@vru2]eu
jZY]U=EC@t]Vutubt&u"hHC@YuhTC@yYt+20
HC@
LC@
PC@
TC@
XC@
\C@EC@^]j/jh6@KeMZf9@u]<@@PEuLf9@u>E@+PQ|YYt'x$|!EE3Ɂ8ËeE2Md
Y_^[Ut}u	3@C@]U=DC@t}uuuYY]U=HC@uuThHC@BYY#E]UuYH]UeEeP(0@E3EE,0@1E00@1EEP40@EM3E3E3Ë
@@VWN@;tu&;uO@u

Gȉ
@@_
@@^33@ø@h`C@$0@ðhhjguj?hC@H$HHH39@@øC@øC@U$Sj80@tM)j$jPF|xffftfpflfhEEDž@jPEjPEE@EE 0@jXۍEEۉED0@EPH0@uujY[ejL0@t3MZf9u)H<ȁ9PEuf9Auytv2h!@D0@UVW}7>csmu%~uF= t=!t="t=@t_3^]0w0\̃%pC@SV5@5@;sW>t
1@׃;r_^[SV5@5@;sW>t
1@׃;r_^[h"@d5D$l$l$+SVW@@1E3PeuEEEEdUVu6uuuVh2@h@@^]U%tC@$
@@j
80@e3SVW3ɍ}S[wO3ɉWE܋}EGenuE5ineIEE5ntelE3@S[]܉EEljsKSuCE%?=t#=`t=pt=Pt=`t=pu=xC@=xC@=xC@MjXM9E|03S[]܉sKMS]t=xC@]@@tC@@@tC@@@tytq3ЉEUEMj^#;uW@@tC@@@ t; tC@@@#;uEM#;u

@@@5tC@_^[339@@%T0@%X0@%`0@%\0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%1@%0@%0@%0@%0@%t0@%0@%0@%0@%0@%0@%0@%0@%0@%0@UQ=tC@|f}t	}uT]E?t?uét*uéué uøËE8"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999@@@@@failed to create process.
failed to get exit code from process.
%s %s-script.pyCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %s @@p@@@@3@1@3@ 1@'hd
l`3`"3,H3"(##$$$$c$k$@"N%x.text$mn0.idata$51.00cfg$1.CRT$XCA(1.CRT$XCAA,1.CRT$XCZ01.CRT$XIA41.CRT$XIAA81.CRT$XIAC<1.CRT$XIZ@1.CRT$XPAD1.CRT$XPZH1.CRT$XTAL1.CRT$XTZP1.rdata3.rdata$sxdata3\.rdata$voltmd`3l.rdata$zzzdbg5.rtc$IAA5.rtc$IZZ5.rtc$TAA5.rtc$TZZ5<.xdata$x6.idata$26.idata$36.idata$48.idata$6@.data@x.bssP`.rsrc$01`P.rsrc$02,@@@N@a@680L7,9T0l7;t0`7;h07;07<084<17V<0x7v<07<08"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999CreateFileAdGetFinalPathNameByHandleAWaitForSingleObjectQGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dllHmemset__current_exception__current_exception_context5_except_handler4_commonVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspaceB_seh_filter_exeD_set_app_type.__setusermatherr_configure_narrow_argv5_initialize_narrow_environment*_get_initial_narrow_environment8_initterm9_initterm_eXexit%_exitT_set_fmode_cexit_c_exit?_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode6_initialize_onexit_table>_register_onexit_function_crt_atexit_controlfp_sjterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllUnhandledExceptionFilterSetUnhandledExceptionFilter,GetCurrentProcessTerminateProcessIsProcessorFeaturePresentmQueryPerformanceCounter-GetCurrentProcessId1GetCurrentThreadIdGetSystemTimeAsFileTimeInitializeSListHeadIsDebuggerPresentGetModuleHandleWDN@0	H`P}

  
    
      
        
      
    
  

00'0[00J1u1111222<2D222222303H3j3)4<4s4M5S5w555555666>7I777(8P8Y8a888888!949x99:3:H:M:R:s:x:::;;;;;;;;;;;;<<<<<#<+<3<;>> >*>>>>>?'?0?=?S?????? 000%0011;1z11111122*2A2^222222u3~33333333+444=4K4T4v4}4444444444444444444455555 5&5,52585>5D5J5T50(1(1418122L2P2X2225566././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5395505
setuptools-68.1.2/setuptools/command/0000755000175100001730000000000014467657444017316 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/__init__.py0000644000175100001730000000061414467657412021423 0ustar00runnerdockerfrom distutils.command.bdist import bdist
import sys

if 'egg' not in bdist.format_commands:
    try:
        bdist.format_commands['egg'] = ('bdist_egg', "Python .egg file")
    except TypeError:
        # For backward compatibility with older distutils (stdlib)
        bdist.format_command['egg'] = ('bdist_egg', "Python .egg file")
        bdist.format_commands.append('egg')

del bdist, sys
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/alias.py0000644000175100001730000000451714467657412020763 0ustar00runnerdockerfrom distutils.errors import DistutilsOptionError

from setuptools.command.setopt import edit_config, option_base, config_file


def shquote(arg):
    """Quote an argument for later parsing by shlex.split()"""
    for c in '"', "'", "\\", "#":
        if c in arg:
            return repr(arg)
    if arg.split() != [arg]:
        return repr(arg)
    return arg


class alias(option_base):
    """Define a shortcut that invokes one or more commands"""

    description = "define a shortcut to invoke one or more commands"
    command_consumes_arguments = True

    user_options = [
        ('remove', 'r', 'remove (unset) the alias'),
    ] + option_base.user_options

    boolean_options = option_base.boolean_options + ['remove']

    def initialize_options(self):
        option_base.initialize_options(self)
        self.args = None
        self.remove = None

    def finalize_options(self):
        option_base.finalize_options(self)
        if self.remove and len(self.args) != 1:
            raise DistutilsOptionError(
                "Must specify exactly one argument (the alias name) when "
                "using --remove"
            )

    def run(self):
        aliases = self.distribution.get_option_dict('aliases')

        if not self.args:
            print("Command Aliases")
            print("---------------")
            for alias in aliases:
                print("setup.py alias", format_alias(alias, aliases))
            return

        elif len(self.args) == 1:
            (alias,) = self.args
            if self.remove:
                command = None
            elif alias in aliases:
                print("setup.py alias", format_alias(alias, aliases))
                return
            else:
                print("No alias definition found for %r" % alias)
                return
        else:
            alias = self.args[0]
            command = ' '.join(map(shquote, self.args[1:]))

        edit_config(self.filename, {'aliases': {alias: command}}, self.dry_run)


def format_alias(name, aliases):
    source, command = aliases[name]
    if source == config_file('global'):
        source = '--global-config '
    elif source == config_file('user'):
        source = '--user-config '
    elif source == config_file('local'):
        source = ''
    else:
        source = '--filename=%r' % source
    return source + name + ' ' + command
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/bdist_egg.py0000644000175100001730000004025714467657412021622 0ustar00runnerdocker"""setuptools.command.bdist_egg

Build .egg distributions"""

from distutils.dir_util import remove_tree, mkpath
from distutils import log
from types import CodeType
import sys
import os
import re
import textwrap
import marshal

from setuptools.extension import Library
from setuptools import Command
from .._path import ensure_directory

from sysconfig import get_path, get_python_version


def _get_purelib():
    return get_path("purelib")


def strip_module(filename):
    if '.' in filename:
        filename = os.path.splitext(filename)[0]
    if filename.endswith('module'):
        filename = filename[:-6]
    return filename


def sorted_walk(dir):
    """Do os.walk in a reproducible way,
    independent of indeterministic filesystem readdir order
    """
    for base, dirs, files in os.walk(dir):
        dirs.sort()
        files.sort()
        yield base, dirs, files


def write_stub(resource, pyfile):
    _stub_template = textwrap.dedent(
        """
        def __bootstrap__():
            global __bootstrap__, __loader__, __file__
            import sys, pkg_resources, importlib.util
            __file__ = pkg_resources.resource_filename(__name__, %r)
            __loader__ = None; del __bootstrap__, __loader__
            spec = importlib.util.spec_from_file_location(__name__,__file__)
            mod = importlib.util.module_from_spec(spec)
            spec.loader.exec_module(mod)
        __bootstrap__()
        """
    ).lstrip()
    with open(pyfile, 'w') as f:
        f.write(_stub_template % resource)


class bdist_egg(Command):
    description = "create an \"egg\" distribution"

    user_options = [
        ('bdist-dir=', 'b', "temporary directory for creating the distribution"),
        (
            'plat-name=',
            'p',
            "platform name to embed in generated filenames "
            "(by default uses `pkg_resources.get_build_platform()`)",
        ),
        ('exclude-source-files', None, "remove all .py files from the generated egg"),
        (
            'keep-temp',
            'k',
            "keep the pseudo-installation tree around after "
            + "creating the distribution archive",
        ),
        ('dist-dir=', 'd', "directory to put final built distributions in"),
        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
    ]

    boolean_options = ['keep-temp', 'skip-build', 'exclude-source-files']

    def initialize_options(self):
        self.bdist_dir = None
        self.plat_name = None
        self.keep_temp = 0
        self.dist_dir = None
        self.skip_build = 0
        self.egg_output = None
        self.exclude_source_files = None

    def finalize_options(self):
        ei_cmd = self.ei_cmd = self.get_finalized_command("egg_info")
        self.egg_info = ei_cmd.egg_info

        if self.bdist_dir is None:
            bdist_base = self.get_finalized_command('bdist').bdist_base
            self.bdist_dir = os.path.join(bdist_base, 'egg')

        if self.plat_name is None:
            from pkg_resources import get_build_platform

            self.plat_name = get_build_platform()

        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))

        if self.egg_output is None:
            # Compute filename of the output egg
            basename = ei_cmd._get_egg_basename(
                py_version=get_python_version(),
                platform=self.distribution.has_ext_modules() and self.plat_name,
            )

            self.egg_output = os.path.join(self.dist_dir, basename + '.egg')

    def do_install_data(self):
        # Hack for packages that install data to install's --install-lib
        self.get_finalized_command('install').install_lib = self.bdist_dir

        site_packages = os.path.normcase(os.path.realpath(_get_purelib()))
        old, self.distribution.data_files = self.distribution.data_files, []

        for item in old:
            if isinstance(item, tuple) and len(item) == 2:
                if os.path.isabs(item[0]):
                    realpath = os.path.realpath(item[0])
                    normalized = os.path.normcase(realpath)
                    if normalized == site_packages or normalized.startswith(
                        site_packages + os.sep
                    ):
                        item = realpath[len(site_packages) + 1 :], item[1]
                        # XXX else: raise ???
            self.distribution.data_files.append(item)

        try:
            log.info("installing package data to %s", self.bdist_dir)
            self.call_command('install_data', force=0, root=None)
        finally:
            self.distribution.data_files = old

    def get_outputs(self):
        return [self.egg_output]

    def call_command(self, cmdname, **kw):
        """Invoke reinitialized command `cmdname` with keyword args"""
        for dirname in INSTALL_DIRECTORY_ATTRS:
            kw.setdefault(dirname, self.bdist_dir)
        kw.setdefault('skip_build', self.skip_build)
        kw.setdefault('dry_run', self.dry_run)
        cmd = self.reinitialize_command(cmdname, **kw)
        self.run_command(cmdname)
        return cmd

    def run(self):  # noqa: C901  # is too complex (14)  # FIXME
        # Generate metadata first
        self.run_command("egg_info")
        # We run install_lib before install_data, because some data hacks
        # pull their data path from the install_lib command.
        log.info("installing library code to %s", self.bdist_dir)
        instcmd = self.get_finalized_command('install')
        old_root = instcmd.root
        instcmd.root = None
        if self.distribution.has_c_libraries() and not self.skip_build:
            self.run_command('build_clib')
        cmd = self.call_command('install_lib', warn_dir=0)
        instcmd.root = old_root

        all_outputs, ext_outputs = self.get_ext_outputs()
        self.stubs = []
        to_compile = []
        for p, ext_name in enumerate(ext_outputs):
            filename, ext = os.path.splitext(ext_name)
            pyfile = os.path.join(self.bdist_dir, strip_module(filename) + '.py')
            self.stubs.append(pyfile)
            log.info("creating stub loader for %s", ext_name)
            if not self.dry_run:
                write_stub(os.path.basename(ext_name), pyfile)
            to_compile.append(pyfile)
            ext_outputs[p] = ext_name.replace(os.sep, '/')

        if to_compile:
            cmd.byte_compile(to_compile)
        if self.distribution.data_files:
            self.do_install_data()

        # Make the EGG-INFO directory
        archive_root = self.bdist_dir
        egg_info = os.path.join(archive_root, 'EGG-INFO')
        self.mkpath(egg_info)
        if self.distribution.scripts:
            script_dir = os.path.join(egg_info, 'scripts')
            log.info("installing scripts to %s", script_dir)
            self.call_command('install_scripts', install_dir=script_dir, no_ep=1)

        self.copy_metadata_to(egg_info)
        native_libs = os.path.join(egg_info, "native_libs.txt")
        if all_outputs:
            log.info("writing %s", native_libs)
            if not self.dry_run:
                ensure_directory(native_libs)
                libs_file = open(native_libs, 'wt')
                libs_file.write('\n'.join(all_outputs))
                libs_file.write('\n')
                libs_file.close()
        elif os.path.isfile(native_libs):
            log.info("removing %s", native_libs)
            if not self.dry_run:
                os.unlink(native_libs)

        write_safety_flag(os.path.join(archive_root, 'EGG-INFO'), self.zip_safe())

        if os.path.exists(os.path.join(self.egg_info, 'depends.txt')):
            log.warn(
                "WARNING: 'depends.txt' will not be used by setuptools 0.6!\n"
                "Use the install_requires/extras_require setup() args instead."
            )

        if self.exclude_source_files:
            self.zap_pyfiles()

        # Make the archive
        make_zipfile(
            self.egg_output,
            archive_root,
            verbose=self.verbose,
            dry_run=self.dry_run,
            mode=self.gen_header(),
        )
        if not self.keep_temp:
            remove_tree(self.bdist_dir, dry_run=self.dry_run)

        # Add to 'Distribution.dist_files' so that the "upload" command works
        getattr(self.distribution, 'dist_files', []).append(
            ('bdist_egg', get_python_version(), self.egg_output)
        )

    def zap_pyfiles(self):
        log.info("Removing .py files from temporary directory")
        for base, dirs, files in walk_egg(self.bdist_dir):
            for name in files:
                path = os.path.join(base, name)

                if name.endswith('.py'):
                    log.debug("Deleting %s", path)
                    os.unlink(path)

                if base.endswith('__pycache__'):
                    path_old = path

                    pattern = r'(?P.+)\.(?P[^.]+)\.pyc'
                    m = re.match(pattern, name)
                    path_new = os.path.join(base, os.pardir, m.group('name') + '.pyc')
                    log.info("Renaming file from [%s] to [%s]" % (path_old, path_new))
                    try:
                        os.remove(path_new)
                    except OSError:
                        pass
                    os.rename(path_old, path_new)

    def zip_safe(self):
        safe = getattr(self.distribution, 'zip_safe', None)
        if safe is not None:
            return safe
        log.warn("zip_safe flag not set; analyzing archive contents...")
        return analyze_egg(self.bdist_dir, self.stubs)

    def gen_header(self):
        return 'w'

    def copy_metadata_to(self, target_dir):
        "Copy metadata (egg info) to the target_dir"
        # normalize the path (so that a forward-slash in egg_info will
        # match using startswith below)
        norm_egg_info = os.path.normpath(self.egg_info)
        prefix = os.path.join(norm_egg_info, '')
        for path in self.ei_cmd.filelist.files:
            if path.startswith(prefix):
                target = os.path.join(target_dir, path[len(prefix) :])
                ensure_directory(target)
                self.copy_file(path, target)

    def get_ext_outputs(self):
        """Get a list of relative paths to C extensions in the output distro"""

        all_outputs = []
        ext_outputs = []

        paths = {self.bdist_dir: ''}
        for base, dirs, files in sorted_walk(self.bdist_dir):
            for filename in files:
                if os.path.splitext(filename)[1].lower() in NATIVE_EXTENSIONS:
                    all_outputs.append(paths[base] + filename)
            for filename in dirs:
                paths[os.path.join(base, filename)] = paths[base] + filename + '/'

        if self.distribution.has_ext_modules():
            build_cmd = self.get_finalized_command('build_ext')
            for ext in build_cmd.extensions:
                if isinstance(ext, Library):
                    continue
                fullname = build_cmd.get_ext_fullname(ext.name)
                filename = build_cmd.get_ext_filename(fullname)
                if not os.path.basename(filename).startswith('dl-'):
                    if os.path.exists(os.path.join(self.bdist_dir, filename)):
                        ext_outputs.append(filename)

        return all_outputs, ext_outputs


NATIVE_EXTENSIONS = dict.fromkeys('.dll .so .dylib .pyd'.split())


def walk_egg(egg_dir):
    """Walk an unpacked egg's contents, skipping the metadata directory"""
    walker = sorted_walk(egg_dir)
    base, dirs, files = next(walker)
    if 'EGG-INFO' in dirs:
        dirs.remove('EGG-INFO')
    yield base, dirs, files
    for bdf in walker:
        yield bdf


def analyze_egg(egg_dir, stubs):
    # check for existing flag in EGG-INFO
    for flag, fn in safety_flags.items():
        if os.path.exists(os.path.join(egg_dir, 'EGG-INFO', fn)):
            return flag
    if not can_scan():
        return False
    safe = True
    for base, dirs, files in walk_egg(egg_dir):
        for name in files:
            if name.endswith('.py') or name.endswith('.pyw'):
                continue
            elif name.endswith('.pyc') or name.endswith('.pyo'):
                # always scan, even if we already know we're not safe
                safe = scan_module(egg_dir, base, name, stubs) and safe
    return safe


def write_safety_flag(egg_dir, safe):
    # Write or remove zip safety flag file(s)
    for flag, fn in safety_flags.items():
        fn = os.path.join(egg_dir, fn)
        if os.path.exists(fn):
            if safe is None or bool(safe) != flag:
                os.unlink(fn)
        elif safe is not None and bool(safe) == flag:
            f = open(fn, 'wt')
            f.write('\n')
            f.close()


safety_flags = {
    True: 'zip-safe',
    False: 'not-zip-safe',
}


def scan_module(egg_dir, base, name, stubs):
    """Check whether module possibly uses unsafe-for-zipfile stuff"""

    filename = os.path.join(base, name)
    if filename[:-1] in stubs:
        return True  # Extension module
    pkg = base[len(egg_dir) + 1 :].replace(os.sep, '.')
    module = pkg + (pkg and '.' or '') + os.path.splitext(name)[0]
    if sys.version_info < (3, 7):
        skip = 12  # skip magic & date & file size
    else:
        skip = 16  # skip magic & reserved? & date & file size
    f = open(filename, 'rb')
    f.read(skip)
    code = marshal.load(f)
    f.close()
    safe = True
    symbols = dict.fromkeys(iter_symbols(code))
    for bad in ['__file__', '__path__']:
        if bad in symbols:
            log.warn("%s: module references %s", module, bad)
            safe = False
    if 'inspect' in symbols:
        for bad in [
            'getsource',
            'getabsfile',
            'getsourcefile',
            'getfile' 'getsourcelines',
            'findsource',
            'getcomments',
            'getframeinfo',
            'getinnerframes',
            'getouterframes',
            'stack',
            'trace',
        ]:
            if bad in symbols:
                log.warn("%s: module MAY be using inspect.%s", module, bad)
                safe = False
    return safe


def iter_symbols(code):
    """Yield names and strings used by `code` and its nested code objects"""
    for name in code.co_names:
        yield name
    for const in code.co_consts:
        if isinstance(const, str):
            yield const
        elif isinstance(const, CodeType):
            for name in iter_symbols(const):
                yield name


def can_scan():
    if not sys.platform.startswith('java') and sys.platform != 'cli':
        # CPython, PyPy, etc.
        return True
    log.warn("Unable to analyze compiled code on this platform.")
    log.warn(
        "Please ask the author to include a 'zip_safe'"
        " setting (either True or False) in the package's setup.py"
    )


# Attribute names of options for commands that might need to be convinced to
# install to the egg build directory

INSTALL_DIRECTORY_ATTRS = ['install_lib', 'install_dir', 'install_data', 'install_base']


def make_zipfile(zip_filename, base_dir, verbose=0, dry_run=0, compress=True, mode='w'):
    """Create a zip file from all the files under 'base_dir'.  The output
    zip file will be named 'base_dir' + ".zip".  Uses either the "zipfile"
    Python module (if available) or the InfoZIP "zip" utility (if installed
    and found on the default search path).  If neither tool is available,
    raises DistutilsExecError.  Returns the name of the output zip file.
    """
    import zipfile

    mkpath(os.path.dirname(zip_filename), dry_run=dry_run)
    log.info("creating '%s' and adding '%s' to it", zip_filename, base_dir)

    def visit(z, dirname, names):
        for name in names:
            path = os.path.normpath(os.path.join(dirname, name))
            if os.path.isfile(path):
                p = path[len(base_dir) + 1 :]
                if not dry_run:
                    z.write(path, p)
                log.debug("adding '%s'", p)

    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
    if not dry_run:
        z = zipfile.ZipFile(zip_filename, mode, compression=compression)
        for dirname, dirs, files in sorted_walk(base_dir):
            visit(z, dirname, files)
        z.close()
    else:
        for dirname, dirs, files in sorted_walk(base_dir):
            visit(None, dirname, files)
    return zip_filename
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/bdist_rpm.py0000644000175100001730000000243514467657412021652 0ustar00runnerdockerimport distutils.command.bdist_rpm as orig

from ..warnings import SetuptoolsDeprecationWarning


class bdist_rpm(orig.bdist_rpm):
    """
    Override the default bdist_rpm behavior to do the following:

    1. Run egg_info to ensure the name and version are properly calculated.
    2. Always run 'install' using --single-version-externally-managed to
       disable eggs in RPM distributions.
    """

    def run(self):
        SetuptoolsDeprecationWarning.emit(
            "Deprecated command",
            """
            bdist_rpm is deprecated and will be removed in a future version.
            Use bdist_wheel (wheel packages) instead.
            """,
            see_url="https://github.com/pypa/setuptools/issues/1988",
            due_date=(2023, 10, 30),  # Deprecation introduced in 22 Oct 2021.
        )

        # ensure distro name is up-to-date
        self.run_command('egg_info')

        orig.bdist_rpm.run(self)

    def _make_spec_file(self):
        spec = orig.bdist_rpm._make_spec_file(self)
        spec = [
            line.replace(
                "setup.py install ",
                "setup.py install --single-version-externally-managed ",
            ).replace("%setup", "%setup -n %{name}-%{unmangled_version}")
            for line in spec
        ]
        return spec
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/build.py0000644000175100001730000001520014467657412020760 0ustar00runnerdockerimport sys
from typing import TYPE_CHECKING, List, Dict
from distutils.command.build import build as _build

from ..warnings import SetuptoolsDeprecationWarning

if sys.version_info >= (3, 8):
    from typing import Protocol
elif TYPE_CHECKING:
    from typing_extensions import Protocol
else:
    from abc import ABC as Protocol


_ORIGINAL_SUBCOMMANDS = {"build_py", "build_clib", "build_ext", "build_scripts"}


class build(_build):
    # copy to avoid sharing the object with parent class
    sub_commands = _build.sub_commands[:]

    def get_sub_commands(self):
        subcommands = {cmd[0] for cmd in _build.sub_commands}
        if subcommands - _ORIGINAL_SUBCOMMANDS:
            SetuptoolsDeprecationWarning.emit(
                "Direct usage of `distutils` commands",
                """
                It seems that you are using `distutils.command.build` to add
                new subcommands. Using `distutils` directly is considered deprecated,
                please use `setuptools.command.build`.
                """,
                due_date=(2023, 12, 13),  # Warning introduced in 13 Jun 2022.
                see_url="https://peps.python.org/pep-0632/",
            )
            self.sub_commands = _build.sub_commands
        return super().get_sub_commands()


class SubCommand(Protocol):
    """In order to support editable installations (see :pep:`660`) all
    build subcommands **SHOULD** implement this protocol. They also **MUST** inherit
    from ``setuptools.Command``.

    When creating an :pep:`editable wheel <660>`, ``setuptools`` will try to evaluate
    custom ``build`` subcommands using the following procedure:

    1. ``setuptools`` will set the ``editable_mode`` attribute to ``True``
    2. ``setuptools`` will execute the ``run()`` command.

       .. important::
          Subcommands **SHOULD** take advantage of ``editable_mode=True`` to adequate
          its behaviour or perform optimisations.

          For example, if a subcommand doesn't need to generate an extra file and
          all it does is to copy a source file into the build directory,
          ``run()`` **SHOULD** simply "early return".

          Similarly, if the subcommand creates files that would be placed alongside
          Python files in the final distribution, during an editable install
          the command **SHOULD** generate these files "in place" (i.e. write them to
          the original source directory, instead of using the build directory).
          Note that ``get_output_mapping()`` should reflect that and include mappings
          for "in place" builds accordingly.

    3. ``setuptools`` use any knowledge it can derive from the return values of
       ``get_outputs()`` and ``get_output_mapping()`` to create an editable wheel.
       When relevant ``setuptools`` **MAY** attempt to use file links based on the value
       of ``get_output_mapping()``. Alternatively, ``setuptools`` **MAY** attempt to use
       :doc:`import hooks ` to redirect any attempt to import
       to the directory with the original source code and other files built in place.

    Please note that custom sub-commands **SHOULD NOT** rely on ``run()`` being
    executed (or not) to provide correct return values for ``get_outputs()``,
    ``get_output_mapping()`` or ``get_source_files()``. The ``get_*`` methods should
    work independently of ``run()``.
    """

    editable_mode: bool = False
    """Boolean flag that will be set to ``True`` when setuptools is used for an
    editable installation (see :pep:`660`).
    Implementations **SHOULD** explicitly set the default value of this attribute to
    ``False``.
    When subcommands run, they can use this flag to perform optimizations or change
    their behaviour accordingly.
    """

    build_lib: str
    """String representing the directory where the build artifacts should be stored,
    e.g. ``build/lib``.
    For example, if a distribution wants to provide a Python module named ``pkg.mod``,
    then a corresponding file should be written to ``{build_lib}/package/module.py``.
    A way of thinking about this is that the files saved under ``build_lib``
    would be eventually copied to one of the directories in :obj:`site.PREFIXES`
    upon installation.

    A command that produces platform-independent files (e.g. compiling text templates
    into Python functions), **CAN** initialize ``build_lib`` by copying its value from
    the ``build_py`` command. On the other hand, a command that produces
    platform-specific files **CAN** initialize ``build_lib`` by copying its value from
    the ``build_ext`` command. In general this is done inside the ``finalize_options``
    method with the help of the ``set_undefined_options`` command::

        def finalize_options(self):
            self.set_undefined_options("build_py", ("build_lib", "build_lib"))
            ...
    """

    def initialize_options(self):
        """(Required by the original :class:`setuptools.Command` interface)"""

    def finalize_options(self):
        """(Required by the original :class:`setuptools.Command` interface)"""

    def run(self):
        """(Required by the original :class:`setuptools.Command` interface)"""

    def get_source_files(self) -> List[str]:
        """
        Return a list of all files that are used by the command to create the expected
        outputs.
        For example, if your build command transpiles Java files into Python, you should
        list here all the Java files.
        The primary purpose of this function is to help populating the ``sdist``
        with all the files necessary to build the distribution.
        All files should be strings relative to the project root directory.
        """

    def get_outputs(self) -> List[str]:
        """
        Return a list of files intended for distribution as they would have been
        produced by the build.
        These files should be strings in the form of
        ``"{build_lib}/destination/file/path"``.

        .. note::
           The return value of ``get_output()`` should include all files used as keys
           in ``get_output_mapping()`` plus files that are generated during the build
           and don't correspond to any source file already present in the project.
        """

    def get_output_mapping(self) -> Dict[str, str]:
        """
        Return a mapping between destination files as they would be produced by the
        build (dict keys) into the respective existing (source) files (dict values).
        Existing (source) files should be represented as strings relative to the project
        root directory.
        Destination files should be strings in the form of
        ``"{build_lib}/destination/file/path"``.
        """
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/build_clib.py0000644000175100001730000001045614467657412021761 0ustar00runnerdockerimport distutils.command.build_clib as orig
from distutils.errors import DistutilsSetupError
from distutils import log
from setuptools.dep_util import newer_pairwise_group


class build_clib(orig.build_clib):
    """
    Override the default build_clib behaviour to do the following:

    1. Implement a rudimentary timestamp-based dependency system
       so 'compile()' doesn't run every time.
    2. Add more keys to the 'build_info' dictionary:
        * obj_deps - specify dependencies for each object compiled.
                     this should be a dictionary mapping a key
                     with the source filename to a list of
                     dependencies. Use an empty string for global
                     dependencies.
        * cflags   - specify a list of additional flags to pass to
                     the compiler.
    """

    def build_libraries(self, libraries):
        for lib_name, build_info in libraries:
            sources = build_info.get('sources')
            if sources is None or not isinstance(sources, (list, tuple)):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'sources' must be present and must be "
                    "a list of source filenames" % lib_name
                )
            sources = sorted(list(sources))

            log.info("building '%s' library", lib_name)

            # Make sure everything is the correct type.
            # obj_deps should be a dictionary of keys as sources
            # and a list/tuple of files that are its dependencies.
            obj_deps = build_info.get('obj_deps', dict())
            if not isinstance(obj_deps, dict):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'obj_deps' must be a dictionary of "
                    "type 'source: list'" % lib_name
                )
            dependencies = []

            # Get the global dependencies that are specified by the '' key.
            # These will go into every source's dependency list.
            global_deps = obj_deps.get('', list())
            if not isinstance(global_deps, (list, tuple)):
                raise DistutilsSetupError(
                    "in 'libraries' option (library '%s'), "
                    "'obj_deps' must be a dictionary of "
                    "type 'source: list'" % lib_name
                )

            # Build the list to be used by newer_pairwise_group
            # each source will be auto-added to its dependencies.
            for source in sources:
                src_deps = [source]
                src_deps.extend(global_deps)
                extra_deps = obj_deps.get(source, list())
                if not isinstance(extra_deps, (list, tuple)):
                    raise DistutilsSetupError(
                        "in 'libraries' option (library '%s'), "
                        "'obj_deps' must be a dictionary of "
                        "type 'source: list'" % lib_name
                    )
                src_deps.extend(extra_deps)
                dependencies.append(src_deps)

            expected_objects = self.compiler.object_filenames(
                sources,
                output_dir=self.build_temp,
            )

            if newer_pairwise_group(dependencies, expected_objects) != ([], []):
                # First, compile the source code to object files in the library
                # directory.  (This should probably change to putting object
                # files in a temporary build directory.)
                macros = build_info.get('macros')
                include_dirs = build_info.get('include_dirs')
                cflags = build_info.get('cflags')
                self.compiler.compile(
                    sources,
                    output_dir=self.build_temp,
                    macros=macros,
                    include_dirs=include_dirs,
                    extra_postargs=cflags,
                    debug=self.debug,
                )

            # Now "link" the object files together into a static library.
            # (On Unix at least, this isn't really linking -- it just
            # builds an archive.  Whatever.)
            self.compiler.create_static_lib(
                expected_objects, lib_name, output_dir=self.build_clib, debug=self.debug
            )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/build_ext.py0000644000175100001730000004214014467657412021643 0ustar00runnerdockerimport os
import sys
import itertools
from importlib.machinery import EXTENSION_SUFFIXES
from importlib.util import cache_from_source as _compiled_file_name
from typing import Dict, Iterator, List, Tuple
from pathlib import Path

from distutils.command.build_ext import build_ext as _du_build_ext
from distutils.ccompiler import new_compiler
from distutils.sysconfig import customize_compiler, get_config_var
from distutils import log

from setuptools.errors import BaseError
from setuptools.extension import Extension, Library

try:
    # Attempt to use Cython for building extensions, if available
    from Cython.Distutils.build_ext import build_ext as _build_ext

    # Additionally, assert that the compiler module will load
    # also. Ref #1229.
    __import__('Cython.Compiler.Main')
except ImportError:
    _build_ext = _du_build_ext

# make sure _config_vars is initialized
get_config_var("LDSHARED")
from distutils.sysconfig import _config_vars as _CONFIG_VARS  # noqa


def _customize_compiler_for_shlib(compiler):
    if sys.platform == "darwin":
        # building .dylib requires additional compiler flags on OSX; here we
        # temporarily substitute the pyconfig.h variables so that distutils'
        # 'customize_compiler' uses them before we build the shared libraries.
        tmp = _CONFIG_VARS.copy()
        try:
            # XXX Help!  I don't have any idea whether these are right...
            _CONFIG_VARS[
                'LDSHARED'
            ] = "gcc -Wl,-x -dynamiclib -undefined dynamic_lookup"
            _CONFIG_VARS['CCSHARED'] = " -dynamiclib"
            _CONFIG_VARS['SO'] = ".dylib"
            customize_compiler(compiler)
        finally:
            _CONFIG_VARS.clear()
            _CONFIG_VARS.update(tmp)
    else:
        customize_compiler(compiler)


have_rtld = False
use_stubs = False
libtype = 'shared'

if sys.platform == "darwin":
    use_stubs = True
elif os.name != 'nt':
    try:
        import dl

        use_stubs = have_rtld = hasattr(dl, 'RTLD_NOW')
    except ImportError:
        pass


def if_dl(s):
    return s if have_rtld else ''


def get_abi3_suffix():
    """Return the file extension for an abi3-compliant Extension()"""
    for suffix in EXTENSION_SUFFIXES:
        if '.abi3' in suffix:  # Unix
            return suffix
        elif suffix == '.pyd':  # Windows
            return suffix


class build_ext(_build_ext):
    editable_mode: bool = False
    inplace: bool = False

    def run(self):
        """Build extensions in build directory, then copy if --inplace"""
        old_inplace, self.inplace = self.inplace, 0
        _build_ext.run(self)
        self.inplace = old_inplace
        if old_inplace:
            self.copy_extensions_to_source()

    def _get_inplace_equivalent(self, build_py, ext: Extension) -> Tuple[str, str]:
        fullname = self.get_ext_fullname(ext.name)
        filename = self.get_ext_filename(fullname)
        modpath = fullname.split('.')
        package = '.'.join(modpath[:-1])
        package_dir = build_py.get_package_dir(package)
        inplace_file = os.path.join(package_dir, os.path.basename(filename))
        regular_file = os.path.join(self.build_lib, filename)
        return (inplace_file, regular_file)

    def copy_extensions_to_source(self):
        build_py = self.get_finalized_command('build_py')
        for ext in self.extensions:
            inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext)

            # Always copy, even if source is older than destination, to ensure
            # that the right extensions for the current Python/platform are
            # used.
            if os.path.exists(regular_file) or not ext.optional:
                self.copy_file(regular_file, inplace_file, level=self.verbose)

            if ext._needs_stub:
                inplace_stub = self._get_equivalent_stub(ext, inplace_file)
                self._write_stub_file(inplace_stub, ext, compile=True)
                # Always compile stub and remove the original (leave the cache behind)
                # (this behaviour was observed in previous iterations of the code)

    def _get_equivalent_stub(self, ext: Extension, output_file: str) -> str:
        dir_ = os.path.dirname(output_file)
        _, _, name = ext.name.rpartition(".")
        return f"{os.path.join(dir_, name)}.py"

    def _get_output_mapping(self) -> Iterator[Tuple[str, str]]:
        if not self.inplace:
            return

        build_py = self.get_finalized_command('build_py')
        opt = self.get_finalized_command('install_lib').optimize or ""

        for ext in self.extensions:
            inplace_file, regular_file = self._get_inplace_equivalent(build_py, ext)
            yield (regular_file, inplace_file)

            if ext._needs_stub:
                # This version of `build_ext` always builds artifacts in another dir,
                # when "inplace=True" is given it just copies them back.
                # This is done in the `copy_extensions_to_source` function, which
                # always compile stub files via `_compile_and_remove_stub`.
                # At the end of the process, a `.pyc` stub file is created without the
                # corresponding `.py`.

                inplace_stub = self._get_equivalent_stub(ext, inplace_file)
                regular_stub = self._get_equivalent_stub(ext, regular_file)
                inplace_cache = _compiled_file_name(inplace_stub, optimization=opt)
                output_cache = _compiled_file_name(regular_stub, optimization=opt)
                yield (output_cache, inplace_cache)

    def get_ext_filename(self, fullname):
        so_ext = os.getenv('SETUPTOOLS_EXT_SUFFIX')
        if so_ext:
            filename = os.path.join(*fullname.split('.')) + so_ext
        else:
            filename = _build_ext.get_ext_filename(self, fullname)
            so_ext = get_config_var('EXT_SUFFIX')

        if fullname in self.ext_map:
            ext = self.ext_map[fullname]
            use_abi3 = getattr(ext, 'py_limited_api') and get_abi3_suffix()
            if use_abi3:
                filename = filename[: -len(so_ext)]
                so_ext = get_abi3_suffix()
                filename = filename + so_ext
            if isinstance(ext, Library):
                fn, ext = os.path.splitext(filename)
                return self.shlib_compiler.library_filename(fn, libtype)
            elif use_stubs and ext._links_to_dynamic:
                d, fn = os.path.split(filename)
                return os.path.join(d, 'dl-' + fn)
        return filename

    def initialize_options(self):
        _build_ext.initialize_options(self)
        self.shlib_compiler = None
        self.shlibs = []
        self.ext_map = {}
        self.editable_mode = False

    def finalize_options(self):
        _build_ext.finalize_options(self)
        self.extensions = self.extensions or []
        self.check_extensions_list(self.extensions)
        self.shlibs = [ext for ext in self.extensions if isinstance(ext, Library)]
        if self.shlibs:
            self.setup_shlib_compiler()
        for ext in self.extensions:
            ext._full_name = self.get_ext_fullname(ext.name)
        for ext in self.extensions:
            fullname = ext._full_name
            self.ext_map[fullname] = ext

            # distutils 3.1 will also ask for module names
            # XXX what to do with conflicts?
            self.ext_map[fullname.split('.')[-1]] = ext

            ltd = self.shlibs and self.links_to_dynamic(ext) or False
            ns = ltd and use_stubs and not isinstance(ext, Library)
            ext._links_to_dynamic = ltd
            ext._needs_stub = ns
            filename = ext._file_name = self.get_ext_filename(fullname)
            libdir = os.path.dirname(os.path.join(self.build_lib, filename))
            if ltd and libdir not in ext.library_dirs:
                ext.library_dirs.append(libdir)
            if ltd and use_stubs and os.curdir not in ext.runtime_library_dirs:
                ext.runtime_library_dirs.append(os.curdir)

        if self.editable_mode:
            self.inplace = True

    def setup_shlib_compiler(self):
        compiler = self.shlib_compiler = new_compiler(
            compiler=self.compiler, dry_run=self.dry_run, force=self.force
        )
        _customize_compiler_for_shlib(compiler)

        if self.include_dirs is not None:
            compiler.set_include_dirs(self.include_dirs)
        if self.define is not None:
            # 'define' option is a list of (name,value) tuples
            for name, value in self.define:
                compiler.define_macro(name, value)
        if self.undef is not None:
            for macro in self.undef:
                compiler.undefine_macro(macro)
        if self.libraries is not None:
            compiler.set_libraries(self.libraries)
        if self.library_dirs is not None:
            compiler.set_library_dirs(self.library_dirs)
        if self.rpath is not None:
            compiler.set_runtime_library_dirs(self.rpath)
        if self.link_objects is not None:
            compiler.set_link_objects(self.link_objects)

        # hack so distutils' build_extension() builds a library instead
        compiler.link_shared_object = link_shared_object.__get__(compiler)

    def get_export_symbols(self, ext):
        if isinstance(ext, Library):
            return ext.export_symbols
        return _build_ext.get_export_symbols(self, ext)

    def build_extension(self, ext):
        ext._convert_pyx_sources_to_lang()
        _compiler = self.compiler
        try:
            if isinstance(ext, Library):
                self.compiler = self.shlib_compiler
            _build_ext.build_extension(self, ext)
            if ext._needs_stub:
                build_lib = self.get_finalized_command('build_py').build_lib
                self.write_stub(build_lib, ext)
        finally:
            self.compiler = _compiler

    def links_to_dynamic(self, ext):
        """Return true if 'ext' links to a dynamic lib in the same package"""
        # XXX this should check to ensure the lib is actually being built
        # XXX as dynamic, and not just using a locally-found version or a
        # XXX static-compiled version
        libnames = dict.fromkeys([lib._full_name for lib in self.shlibs])
        pkg = '.'.join(ext._full_name.split('.')[:-1] + [''])
        return any(pkg + libname in libnames for libname in ext.libraries)

    def get_source_files(self) -> List[str]:
        return [*_build_ext.get_source_files(self), *self._get_internal_depends()]

    def _get_internal_depends(self) -> Iterator[str]:
        """Yield ``ext.depends`` that are contained by the project directory"""
        project_root = Path(self.distribution.src_root or os.curdir).resolve()
        depends = (dep for ext in self.extensions for dep in ext.depends)

        def skip(orig_path: str, reason: str) -> None:
            log.info(
                "dependency %s won't be automatically "
                "included in the manifest: the path %s",
                orig_path,
                reason,
            )

        for dep in depends:
            path = Path(dep)

            if path.is_absolute():
                skip(dep, "must be relative")
                continue

            if ".." in path.parts:
                skip(dep, "can't have `..` segments")
                continue

            try:
                resolved = (project_root / path).resolve(strict=True)
            except OSError:
                skip(dep, "doesn't exist")
                continue

            try:
                resolved.relative_to(project_root)
            except ValueError:
                skip(dep, "must be inside the project root")
                continue

            yield path.as_posix()

    def get_outputs(self) -> List[str]:
        if self.inplace:
            return list(self.get_output_mapping().keys())
        return sorted(_build_ext.get_outputs(self) + self.__get_stubs_outputs())

    def get_output_mapping(self) -> Dict[str, str]:
        """See :class:`setuptools.commands.build.SubCommand`"""
        mapping = self._get_output_mapping()
        return dict(sorted(mapping, key=lambda x: x[0]))

    def __get_stubs_outputs(self):
        # assemble the base name for each extension that needs a stub
        ns_ext_bases = (
            os.path.join(self.build_lib, *ext._full_name.split('.'))
            for ext in self.extensions
            if ext._needs_stub
        )
        # pair each base with the extension
        pairs = itertools.product(ns_ext_bases, self.__get_output_extensions())
        return list(base + fnext for base, fnext in pairs)

    def __get_output_extensions(self):
        yield '.py'
        yield '.pyc'
        if self.get_finalized_command('build_py').optimize:
            yield '.pyo'

    def write_stub(self, output_dir, ext, compile=False):
        stub_file = os.path.join(output_dir, *ext._full_name.split('.')) + '.py'
        self._write_stub_file(stub_file, ext, compile)

    def _write_stub_file(self, stub_file: str, ext: Extension, compile=False):
        log.info("writing stub loader for %s to %s", ext._full_name, stub_file)
        if compile and os.path.exists(stub_file):
            raise BaseError(stub_file + " already exists! Please delete.")
        if not self.dry_run:
            f = open(stub_file, 'w')
            f.write(
                '\n'.join(
                    [
                        "def __bootstrap__():",
                        "   global __bootstrap__, __file__, __loader__",
                        "   import sys, os, pkg_resources, importlib.util"
                        + if_dl(", dl"),
                        "   __file__ = pkg_resources.resource_filename"
                        "(__name__,%r)" % os.path.basename(ext._file_name),
                        "   del __bootstrap__",
                        "   if '__loader__' in globals():",
                        "       del __loader__",
                        if_dl("   old_flags = sys.getdlopenflags()"),
                        "   old_dir = os.getcwd()",
                        "   try:",
                        "     os.chdir(os.path.dirname(__file__))",
                        if_dl("     sys.setdlopenflags(dl.RTLD_NOW)"),
                        "     spec = importlib.util.spec_from_file_location(",
                        "                __name__, __file__)",
                        "     mod = importlib.util.module_from_spec(spec)",
                        "     spec.loader.exec_module(mod)",
                        "   finally:",
                        if_dl("     sys.setdlopenflags(old_flags)"),
                        "     os.chdir(old_dir)",
                        "__bootstrap__()",
                        "",  # terminal \n
                    ]
                )
            )
            f.close()
        if compile:
            self._compile_and_remove_stub(stub_file)

    def _compile_and_remove_stub(self, stub_file: str):
        from distutils.util import byte_compile

        byte_compile([stub_file], optimize=0, force=True, dry_run=self.dry_run)
        optimize = self.get_finalized_command('install_lib').optimize
        if optimize > 0:
            byte_compile(
                [stub_file], optimize=optimize, force=True, dry_run=self.dry_run
            )
        if os.path.exists(stub_file) and not self.dry_run:
            os.unlink(stub_file)


if use_stubs or os.name == 'nt':
    # Build shared libraries
    #
    def link_shared_object(
        self,
        objects,
        output_libname,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        self.link(
            self.SHARED_LIBRARY,
            objects,
            output_libname,
            output_dir,
            libraries,
            library_dirs,
            runtime_library_dirs,
            export_symbols,
            debug,
            extra_preargs,
            extra_postargs,
            build_temp,
            target_lang,
        )

else:
    # Build static libraries everywhere else
    libtype = 'static'

    def link_shared_object(
        self,
        objects,
        output_libname,
        output_dir=None,
        libraries=None,
        library_dirs=None,
        runtime_library_dirs=None,
        export_symbols=None,
        debug=0,
        extra_preargs=None,
        extra_postargs=None,
        build_temp=None,
        target_lang=None,
    ):
        # XXX we need to either disallow these attrs on Library instances,
        # or warn/abort here if set, or something...
        # libraries=None, library_dirs=None, runtime_library_dirs=None,
        # export_symbols=None, extra_preargs=None, extra_postargs=None,
        # build_temp=None

        assert output_dir is None  # distutils build_ext doesn't pass this
        output_dir, filename = os.path.split(output_libname)
        basename, ext = os.path.splitext(filename)
        if self.library_filename("x").startswith('lib'):
            # strip 'lib' prefix; this is kludgy if some platform uses
            # a different prefix
            basename = basename[3:]

        self.create_static_lib(objects, basename, output_dir, debug, target_lang)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/build_py.py0000644000175100001730000003522514467657412021501 0ustar00runnerdockerfrom functools import partial
from glob import glob
from distutils.util import convert_path
import distutils.command.build_py as orig
import os
import fnmatch
import textwrap
import io
import distutils.errors
import itertools
import stat
from pathlib import Path
from typing import Dict, Iterable, Iterator, List, Optional, Tuple

from ..extern.more_itertools import unique_everseen
from ..warnings import SetuptoolsDeprecationWarning


def make_writable(target):
    os.chmod(target, os.stat(target).st_mode | stat.S_IWRITE)


class build_py(orig.build_py):
    """Enhanced 'build_py' command that includes data files with packages

    The data files are specified via a 'package_data' argument to 'setup()'.
    See 'setuptools.dist.Distribution' for more details.

    Also, this version of the 'build_py' command allows you to specify both
    'py_modules' and 'packages' in the same setup operation.
    """

    editable_mode: bool = False
    existing_egg_info_dir: Optional[str] = None  #: Private API, internal use only.

    def finalize_options(self):
        orig.build_py.finalize_options(self)
        self.package_data = self.distribution.package_data
        self.exclude_package_data = self.distribution.exclude_package_data or {}
        if 'data_files' in self.__dict__:
            del self.__dict__['data_files']
        self.__updated_files = []

    def copy_file(
        self, infile, outfile, preserve_mode=1, preserve_times=1, link=None, level=1
    ):
        # Overwrite base class to allow using links
        if link:
            infile = str(Path(infile).resolve())
            outfile = str(Path(outfile).resolve())
        return super().copy_file(
            infile, outfile, preserve_mode, preserve_times, link, level
        )

    def run(self):
        """Build modules, packages, and copy data files to build directory"""
        if not (self.py_modules or self.packages) or self.editable_mode:
            return

        if self.py_modules:
            self.build_modules()

        if self.packages:
            self.build_packages()
            self.build_package_data()

        # Only compile actual .py files, using our base class' idea of what our
        # output files are.
        self.byte_compile(orig.build_py.get_outputs(self, include_bytecode=0))

    def __getattr__(self, attr):
        "lazily compute data files"
        if attr == 'data_files':
            self.data_files = self._get_data_files()
            return self.data_files
        return orig.build_py.__getattr__(self, attr)

    def build_module(self, module, module_file, package):
        outfile, copied = orig.build_py.build_module(self, module, module_file, package)
        if copied:
            self.__updated_files.append(outfile)
        return outfile, copied

    def _get_data_files(self):
        """Generate list of '(package,src_dir,build_dir,filenames)' tuples"""
        self.analyze_manifest()
        return list(map(self._get_pkg_data_files, self.packages or ()))

    def get_data_files_without_manifest(self):
        """
        Generate list of ``(package,src_dir,build_dir,filenames)`` tuples,
        but without triggering any attempt to analyze or build the manifest.
        """
        # Prevent eventual errors from unset `manifest_files`
        # (that would otherwise be set by `analyze_manifest`)
        self.__dict__.setdefault('manifest_files', {})
        return list(map(self._get_pkg_data_files, self.packages or ()))

    def _get_pkg_data_files(self, package):
        # Locate package source directory
        src_dir = self.get_package_dir(package)

        # Compute package build directory
        build_dir = os.path.join(*([self.build_lib] + package.split('.')))

        # Strip directory from globbed filenames
        filenames = [
            os.path.relpath(file, src_dir)
            for file in self.find_data_files(package, src_dir)
        ]
        return package, src_dir, build_dir, filenames

    def find_data_files(self, package, src_dir):
        """Return filenames for package's data files in 'src_dir'"""
        patterns = self._get_platform_patterns(
            self.package_data,
            package,
            src_dir,
        )
        globs_expanded = map(partial(glob, recursive=True), patterns)
        # flatten the expanded globs into an iterable of matches
        globs_matches = itertools.chain.from_iterable(globs_expanded)
        glob_files = filter(os.path.isfile, globs_matches)
        files = itertools.chain(
            self.manifest_files.get(package, []),
            glob_files,
        )
        return self.exclude_data_files(package, src_dir, files)

    def get_outputs(self, include_bytecode=1) -> List[str]:
        """See :class:`setuptools.commands.build.SubCommand`"""
        if self.editable_mode:
            return list(self.get_output_mapping().keys())
        return super().get_outputs(include_bytecode)

    def get_output_mapping(self) -> Dict[str, str]:
        """See :class:`setuptools.commands.build.SubCommand`"""
        mapping = itertools.chain(
            self._get_package_data_output_mapping(),
            self._get_module_mapping(),
        )
        return dict(sorted(mapping, key=lambda x: x[0]))

    def _get_module_mapping(self) -> Iterator[Tuple[str, str]]:
        """Iterate over all modules producing (dest, src) pairs."""
        for package, module, module_file in self.find_all_modules():
            package = package.split('.')
            filename = self.get_module_outfile(self.build_lib, package, module)
            yield (filename, module_file)

    def _get_package_data_output_mapping(self) -> Iterator[Tuple[str, str]]:
        """Iterate over package data producing (dest, src) pairs."""
        for package, src_dir, build_dir, filenames in self.data_files:
            for filename in filenames:
                target = os.path.join(build_dir, filename)
                srcfile = os.path.join(src_dir, filename)
                yield (target, srcfile)

    def build_package_data(self):
        """Copy data files into build directory"""
        for target, srcfile in self._get_package_data_output_mapping():
            self.mkpath(os.path.dirname(target))
            _outf, _copied = self.copy_file(srcfile, target)
            make_writable(target)

    def analyze_manifest(self):
        self.manifest_files = mf = {}
        if not self.distribution.include_package_data:
            return
        src_dirs = {}
        for package in self.packages or ():
            # Locate package source directory
            src_dirs[assert_relative(self.get_package_dir(package))] = package

        if (
            getattr(self, 'existing_egg_info_dir', None)
            and Path(self.existing_egg_info_dir, "SOURCES.txt").exists()
        ):
            egg_info_dir = self.existing_egg_info_dir
            manifest = Path(egg_info_dir, "SOURCES.txt")
            files = manifest.read_text(encoding="utf-8").splitlines()
        else:
            self.run_command('egg_info')
            ei_cmd = self.get_finalized_command('egg_info')
            egg_info_dir = ei_cmd.egg_info
            files = ei_cmd.filelist.files

        check = _IncludePackageDataAbuse()
        for path in self._filter_build_files(files, egg_info_dir):
            d, f = os.path.split(assert_relative(path))
            prev = None
            oldf = f
            while d and d != prev and d not in src_dirs:
                prev = d
                d, df = os.path.split(d)
                f = os.path.join(df, f)
            if d in src_dirs:
                if f == oldf:
                    if check.is_module(f):
                        continue  # it's a module, not data
                else:
                    importable = check.importable_subpackage(src_dirs[d], f)
                    if importable:
                        check.warn(importable)
                mf.setdefault(src_dirs[d], []).append(path)

    def _filter_build_files(self, files: Iterable[str], egg_info: str) -> Iterator[str]:
        """
        ``build_meta`` may try to create egg_info outside of the project directory,
        and this can be problematic for certain plugins (reported in issue #3500).

        Extensions might also include between their sources files created on the
        ``build_lib`` and ``build_temp`` directories.

        This function should filter this case of invalid files out.
        """
        build = self.get_finalized_command("build")
        build_dirs = (egg_info, self.build_lib, build.build_temp, build.build_base)
        norm_dirs = [os.path.normpath(p) for p in build_dirs if p]

        for file in files:
            norm_path = os.path.normpath(file)
            if not os.path.isabs(file) or all(d not in norm_path for d in norm_dirs):
                yield file

    def get_data_files(self):
        pass  # Lazily compute data files in _get_data_files() function.

    def check_package(self, package, package_dir):
        """Check namespace packages' __init__ for declare_namespace"""
        try:
            return self.packages_checked[package]
        except KeyError:
            pass

        init_py = orig.build_py.check_package(self, package, package_dir)
        self.packages_checked[package] = init_py

        if not init_py or not self.distribution.namespace_packages:
            return init_py

        for pkg in self.distribution.namespace_packages:
            if pkg == package or pkg.startswith(package + '.'):
                break
        else:
            return init_py

        with io.open(init_py, 'rb') as f:
            contents = f.read()
        if b'declare_namespace' not in contents:
            raise distutils.errors.DistutilsError(
                "Namespace package problem: %s is a namespace package, but "
                "its\n__init__.py does not call declare_namespace()! Please "
                'fix it.\n(See the setuptools manual under '
                '"Namespace Packages" for details.)\n"' % (package,)
            )
        return init_py

    def initialize_options(self):
        self.packages_checked = {}
        orig.build_py.initialize_options(self)
        self.editable_mode = False
        self.existing_egg_info_dir = None

    def get_package_dir(self, package):
        res = orig.build_py.get_package_dir(self, package)
        if self.distribution.src_root is not None:
            return os.path.join(self.distribution.src_root, res)
        return res

    def exclude_data_files(self, package, src_dir, files):
        """Filter filenames for package's data files in 'src_dir'"""
        files = list(files)
        patterns = self._get_platform_patterns(
            self.exclude_package_data,
            package,
            src_dir,
        )
        match_groups = (fnmatch.filter(files, pattern) for pattern in patterns)
        # flatten the groups of matches into an iterable of matches
        matches = itertools.chain.from_iterable(match_groups)
        bad = set(matches)
        keepers = (fn for fn in files if fn not in bad)
        # ditch dupes
        return list(unique_everseen(keepers))

    @staticmethod
    def _get_platform_patterns(spec, package, src_dir):
        """
        yield platform-specific path patterns (suitable for glob
        or fn_match) from a glob-based spec (such as
        self.package_data or self.exclude_package_data)
        matching package in src_dir.
        """
        raw_patterns = itertools.chain(
            spec.get('', []),
            spec.get(package, []),
        )
        return (
            # Each pattern has to be converted to a platform-specific path
            os.path.join(src_dir, convert_path(pattern))
            for pattern in raw_patterns
        )


def assert_relative(path):
    if not os.path.isabs(path):
        return path
    from distutils.errors import DistutilsSetupError

    msg = (
        textwrap.dedent(
            """
        Error: setup script specifies an absolute path:

            %s

        setup() arguments must *always* be /-separated paths relative to the
        setup.py directory, *never* absolute paths.
        """
        ).lstrip()
        % path
    )
    raise DistutilsSetupError(msg)


class _IncludePackageDataAbuse:
    """Inform users that package or module is included as 'data file'"""

    class _Warning(SetuptoolsDeprecationWarning):
        _SUMMARY = """
        Package {importable!r} is absent from the `packages` configuration.
        """

        _DETAILS = """
        ############################
        # Package would be ignored #
        ############################
        Python recognizes {importable!r} as an importable package[^1],
        but it is absent from setuptools' `packages` configuration.

        This leads to an ambiguous overall configuration. If you want to distribute this
        package, please make sure that {importable!r} is explicitly added
        to the `packages` configuration field.

        Alternatively, you can also rely on setuptools' discovery methods
        (for example by using `find_namespace_packages(...)`/`find_namespace:`
        instead of `find_packages(...)`/`find:`).

        You can read more about "package discovery" on setuptools documentation page:

        - https://setuptools.pypa.io/en/latest/userguide/package_discovery.html

        If you don't want {importable!r} to be distributed and are
        already explicitly excluding {importable!r} via
        `find_namespace_packages(...)/find_namespace` or `find_packages(...)/find`,
        you can try to use `exclude_package_data`, or `include-package-data=False` in
        combination with a more fine grained `package-data` configuration.

        You can read more about "package data files" on setuptools documentation page:

        - https://setuptools.pypa.io/en/latest/userguide/datafiles.html


        [^1]: For Python, any directory (with suitable naming) can be imported,
              even if it does not contain any `.py` files.
              On the other hand, currently there is no concept of package data
              directory, all directories are treated like packages.
        """
        # _DUE_DATE: still not defined as this is particularly controversial.
        # Warning initially introduced in May 2022. See issue #3340 for discussion.

    def __init__(self):
        self._already_warned = set()

    def is_module(self, file):
        return file.endswith(".py") and file[: -len(".py")].isidentifier()

    def importable_subpackage(self, parent, file):
        pkg = Path(file).parent
        parts = list(itertools.takewhile(str.isidentifier, pkg.parts))
        if parts:
            return ".".join([parent, *parts])
        return None

    def warn(self, importable):
        if importable not in self._already_warned:
            self._Warning.emit(importable=importable)
            self._already_warned.add(importable)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/develop.py0000644000175100001730000001510214467657412021320 0ustar00runnerdockerfrom distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
import os
import glob
import io

from setuptools.command.easy_install import easy_install
from setuptools import _path
from setuptools import namespaces
import setuptools


class develop(namespaces.DevelopInstaller, easy_install):
    """Set up package for development"""

    description = "install package in 'development mode'"

    user_options = easy_install.user_options + [
        ("uninstall", "u", "Uninstall this source package"),
        ("egg-path=", None, "Set the path to be used in the .egg-link file"),
    ]

    boolean_options = easy_install.boolean_options + ['uninstall']

    command_consumes_arguments = False  # override base

    def run(self):
        if self.uninstall:
            self.multi_version = True
            self.uninstall_link()
            self.uninstall_namespaces()
        else:
            self.install_for_development()
        self.warn_deprecated_options()

    def initialize_options(self):
        self.uninstall = None
        self.egg_path = None
        easy_install.initialize_options(self)
        self.setup_path = None
        self.always_copy_from = '.'  # always copy eggs installed in curdir

    def finalize_options(self):
        import pkg_resources

        ei = self.get_finalized_command("egg_info")
        self.args = [ei.egg_name]

        easy_install.finalize_options(self)
        self.expand_basedirs()
        self.expand_dirs()
        # pick up setup-dir .egg files only: no .egg-info
        self.package_index.scan(glob.glob('*.egg'))

        egg_link_fn = ei.egg_name + '.egg-link'
        self.egg_link = os.path.join(self.install_dir, egg_link_fn)
        self.egg_base = ei.egg_base
        if self.egg_path is None:
            self.egg_path = os.path.abspath(ei.egg_base)

        target = _path.normpath(self.egg_base)
        egg_path = _path.normpath(os.path.join(self.install_dir, self.egg_path))
        if egg_path != target:
            raise DistutilsOptionError(
                "--egg-path must be a relative path from the install"
                " directory to " + target
            )

        # Make a distribution for the package's source
        self.dist = pkg_resources.Distribution(
            target,
            pkg_resources.PathMetadata(target, os.path.abspath(ei.egg_info)),
            project_name=ei.egg_name,
        )

        self.setup_path = self._resolve_setup_path(
            self.egg_base,
            self.install_dir,
            self.egg_path,
        )

    @staticmethod
    def _resolve_setup_path(egg_base, install_dir, egg_path):
        """
        Generate a path from egg_base back to '.' where the
        setup script resides and ensure that path points to the
        setup path from $install_dir/$egg_path.
        """
        path_to_setup = egg_base.replace(os.sep, '/').rstrip('/')
        if path_to_setup != os.curdir:
            path_to_setup = '../' * (path_to_setup.count('/') + 1)
        resolved = _path.normpath(os.path.join(install_dir, egg_path, path_to_setup))
        curdir = _path.normpath(os.curdir)
        if resolved != curdir:
            raise DistutilsOptionError(
                "Can't get a consistent path to setup script from"
                " installation directory",
                resolved,
                curdir,
            )
        return path_to_setup

    def install_for_development(self):
        self.run_command('egg_info')

        # Build extensions in-place
        self.reinitialize_command('build_ext', inplace=1)
        self.run_command('build_ext')

        if setuptools.bootstrap_install_from:
            self.easy_install(setuptools.bootstrap_install_from)
            setuptools.bootstrap_install_from = None

        self.install_namespaces()

        # create an .egg-link in the installation dir, pointing to our egg
        log.info("Creating %s (link to %s)", self.egg_link, self.egg_base)
        if not self.dry_run:
            with open(self.egg_link, "w") as f:
                f.write(self.egg_path + "\n" + self.setup_path)
        # postprocess the installed distro, fixing up .pth, installing scripts,
        # and handling requirements
        self.process_distribution(None, self.dist, not self.no_deps)

    def uninstall_link(self):
        if os.path.exists(self.egg_link):
            log.info("Removing %s (link to %s)", self.egg_link, self.egg_base)
            egg_link_file = open(self.egg_link)
            contents = [line.rstrip() for line in egg_link_file]
            egg_link_file.close()
            if contents not in ([self.egg_path], [self.egg_path, self.setup_path]):
                log.warn("Link points to %s: uninstall aborted", contents)
                return
            if not self.dry_run:
                os.unlink(self.egg_link)
        if not self.dry_run:
            self.update_pth(self.dist)  # remove any .pth link to us
        if self.distribution.scripts:
            # XXX should also check for entry point scripts!
            log.warn("Note: you must uninstall or replace scripts manually!")

    def install_egg_scripts(self, dist):
        if dist is not self.dist:
            # Installing a dependency, so fall back to normal behavior
            return easy_install.install_egg_scripts(self, dist)

        # create wrapper scripts in the script dir, pointing to dist.scripts

        # new-style...
        self.install_wrapper_scripts(dist)

        # ...and old-style
        for script_name in self.distribution.scripts or []:
            script_path = os.path.abspath(convert_path(script_name))
            script_name = os.path.basename(script_path)
            with io.open(script_path) as strm:
                script_text = strm.read()
            self.install_script(dist, script_name, script_text, script_path)

    def install_wrapper_scripts(self, dist):
        dist = VersionlessRequirement(dist)
        return easy_install.install_wrapper_scripts(self, dist)


class VersionlessRequirement:
    """
    Adapt a pkg_resources.Distribution to simply return the project
    name as the 'requirement' so that scripts will work across
    multiple versions.

    >>> from pkg_resources import Distribution
    >>> dist = Distribution(project_name='foo', version='1.0')
    >>> str(dist.as_requirement())
    'foo==1.0'
    >>> adapted_dist = VersionlessRequirement(dist)
    >>> str(adapted_dist.as_requirement())
    'foo'
    """

    def __init__(self, dist):
        self.__dist = dist

    def __getattr__(self, name):
        return getattr(self.__dist, name)

    def as_requirement(self):
        return self.project_name
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/dist_info.py0000644000175100001730000001022214467657412021636 0ustar00runnerdocker"""
Create a dist_info directory
As defined in the wheel specification
"""

import os
import shutil
import sys
from contextlib import contextmanager
from distutils import log
from distutils.core import Command
from pathlib import Path

from .. import _normalization
from ..warnings import SetuptoolsDeprecationWarning


class dist_info(Command):
    """
    This command is private and reserved for internal use of setuptools,
    users should rely on ``setuptools.build_meta`` APIs.
    """

    description = "DO NOT CALL DIRECTLY, INTERNAL ONLY: create .dist-info directory"

    user_options = [
        (
            'egg-base=',
            'e',
            "directory containing .egg-info directories"
            " (default: top of the source tree)"
            " DEPRECATED: use --output-dir.",
        ),
        (
            'output-dir=',
            'o',
            "directory inside of which the .dist-info will be"
            "created (default: top of the source tree)",
        ),
        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
        ('no-date', 'D', "Don't include date stamp [default]"),
        ('keep-egg-info', None, "*TRANSITIONAL* will be removed in the future"),
    ]

    boolean_options = ['tag-date', 'keep-egg-info']
    negative_opt = {'no-date': 'tag-date'}

    def initialize_options(self):
        self.egg_base = None
        self.output_dir = None
        self.name = None
        self.dist_info_dir = None
        self.tag_date = None
        self.tag_build = None
        self.keep_egg_info = False

    def finalize_options(self):
        if self.egg_base:
            msg = "--egg-base is deprecated for dist_info command. Use --output-dir."
            SetuptoolsDeprecationWarning.emit(msg, due_date=(2023, 9, 26))
            # This command is internal to setuptools, therefore it should be safe
            # to remove the deprecated support soon.
            self.output_dir = self.egg_base or self.output_dir

        dist = self.distribution
        project_dir = dist.src_root or os.curdir
        self.output_dir = Path(self.output_dir or project_dir)

        egg_info = self.reinitialize_command("egg_info")
        egg_info.egg_base = str(self.output_dir)

        if self.tag_date:
            egg_info.tag_date = self.tag_date
        else:
            self.tag_date = egg_info.tag_date

        if self.tag_build:
            egg_info.tag_build = self.tag_build
        else:
            self.tag_build = egg_info.tag_build

        egg_info.finalize_options()
        self.egg_info = egg_info

        name = _normalization.safer_name(dist.get_name())
        version = _normalization.safer_best_effort_version(dist.get_version())
        self.name = f"{name}-{version}"
        self.dist_info_dir = os.path.join(self.output_dir, f"{self.name}.dist-info")

    @contextmanager
    def _maybe_bkp_dir(self, dir_path: str, requires_bkp: bool):
        if requires_bkp:
            bkp_name = f"{dir_path}.__bkp__"
            _rm(bkp_name, ignore_errors=True)
            _copy(dir_path, bkp_name, dirs_exist_ok=True, symlinks=True)
            try:
                yield
            finally:
                _rm(dir_path, ignore_errors=True)
                shutil.move(bkp_name, dir_path)
        else:
            yield

    def run(self):
        self.output_dir.mkdir(parents=True, exist_ok=True)
        self.egg_info.run()
        egg_info_dir = self.egg_info.egg_info
        assert os.path.isdir(egg_info_dir), ".egg-info dir should have been created"

        log.info("creating '{}'".format(os.path.abspath(self.dist_info_dir)))
        bdist_wheel = self.get_finalized_command('bdist_wheel')

        # TODO: if bdist_wheel if merged into setuptools, just add "keep_egg_info" there
        with self._maybe_bkp_dir(egg_info_dir, self.keep_egg_info):
            bdist_wheel.egg2dist(egg_info_dir, self.dist_info_dir)


def _rm(dir_name, **opts):
    if os.path.isdir(dir_name):
        shutil.rmtree(dir_name, **opts)


def _copy(src, dst, **opts):
    if sys.version_info < (3, 8):
        opts.pop("dirs_exist_ok", None)
    shutil.copytree(src, dst, **opts)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/easy_install.py0000644000175100001730000025073514467657412022366 0ustar00runnerdocker"""
Easy Install
------------

A tool for doing automatic download/extract/build of distutils-based Python
packages.  For detailed documentation, see the accompanying EasyInstall.txt
file, or visit the `EasyInstall home page`__.

__ https://setuptools.pypa.io/en/latest/deprecated/easy_install.html

"""

from glob import glob
from distutils.util import get_platform
from distutils.util import convert_path, subst_vars
from distutils.errors import (
    DistutilsArgError,
    DistutilsOptionError,
    DistutilsError,
    DistutilsPlatformError,
)
from distutils import log, dir_util
from distutils.command.build_scripts import first_line_re
from distutils.spawn import find_executable
from distutils.command import install
import sys
import os
import zipimport
import shutil
import tempfile
import zipfile
import re
import stat
import random
import textwrap
import warnings
import site
import struct
import contextlib
import subprocess
import shlex
import io
import configparser
import sysconfig


from sysconfig import get_path

from setuptools import Command
from setuptools.sandbox import run_setup
from setuptools.command import setopt
from setuptools.archive_util import unpack_archive
from setuptools.package_index import (
    PackageIndex,
    parse_requirement_arg,
    URL_SCHEME,
)
from setuptools.command import bdist_egg, egg_info
from setuptools.warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning
from setuptools.wheel import Wheel
from pkg_resources import (
    normalize_path,
    resource_string,
    get_distribution,
    find_distributions,
    Environment,
    Requirement,
    Distribution,
    PathMetadata,
    EggMetadata,
    WorkingSet,
    DistributionNotFound,
    VersionConflict,
    DEVELOP_DIST,
)
import pkg_resources
from .. import py312compat
from .._path import ensure_directory
from ..extern.jaraco.text import yield_lines


# Turn on PEP440Warnings
warnings.filterwarnings("default", category=pkg_resources.PEP440Warning)

__all__ = [
    'easy_install',
    'PthDistributions',
    'extract_wininst_cfg',
    'get_exe_prefixes',
]


def is_64bit():
    return struct.calcsize("P") == 8


def _to_bytes(s):
    return s.encode('utf8')


def isascii(s):
    try:
        s.encode('ascii')
        return True
    except UnicodeError:
        return False


def _one_liner(text):
    return textwrap.dedent(text).strip().replace('\n', '; ')


class easy_install(Command):
    """Manage a download/build/install process"""

    description = "Find/get/install Python packages"
    command_consumes_arguments = True

    user_options = [
        ('prefix=', None, "installation prefix"),
        ("zip-ok", "z", "install package as a zipfile"),
        ("multi-version", "m", "make apps have to require() a version"),
        ("upgrade", "U", "force upgrade (searches PyPI for latest versions)"),
        ("install-dir=", "d", "install package to DIR"),
        ("script-dir=", "s", "install scripts to DIR"),
        ("exclude-scripts", "x", "Don't install scripts"),
        ("always-copy", "a", "Copy all needed packages to install dir"),
        ("index-url=", "i", "base URL of Python Package Index"),
        ("find-links=", "f", "additional URL(s) to search for packages"),
        ("build-directory=", "b", "download/extract/build in DIR; keep the results"),
        (
            'optimize=',
            'O',
            "also compile with optimization: -O1 for \"python -O\", "
            "-O2 for \"python -OO\", and -O0 to disable [default: -O0]",
        ),
        ('record=', None, "filename in which to record list of installed files"),
        ('always-unzip', 'Z', "don't install as a zipfile, no matter what"),
        ('site-dirs=', 'S', "list of directories where .pth files work"),
        ('editable', 'e', "Install specified packages in editable form"),
        ('no-deps', 'N', "don't install dependencies"),
        ('allow-hosts=', 'H', "pattern(s) that hostnames must match"),
        ('local-snapshots-ok', 'l', "allow building eggs from local checkouts"),
        ('version', None, "print version information and exit"),
        (
            'no-find-links',
            None,
            "Don't load find-links defined in packages being installed",
        ),
        ('user', None, "install in user site-package '%s'" % site.USER_SITE),
    ]
    boolean_options = [
        'zip-ok',
        'multi-version',
        'exclude-scripts',
        'upgrade',
        'always-copy',
        'editable',
        'no-deps',
        'local-snapshots-ok',
        'version',
        'user',
    ]

    negative_opt = {'always-unzip': 'zip-ok'}
    create_index = PackageIndex

    def initialize_options(self):
        EasyInstallDeprecationWarning.emit()

        # the --user option seems to be an opt-in one,
        # so the default should be False.
        self.user = 0
        self.zip_ok = self.local_snapshots_ok = None
        self.install_dir = self.script_dir = self.exclude_scripts = None
        self.index_url = None
        self.find_links = None
        self.build_directory = None
        self.args = None
        self.optimize = self.record = None
        self.upgrade = self.always_copy = self.multi_version = None
        self.editable = self.no_deps = self.allow_hosts = None
        self.root = self.prefix = self.no_report = None
        self.version = None
        self.install_purelib = None  # for pure module distributions
        self.install_platlib = None  # non-pure (dists w/ extensions)
        self.install_headers = None  # for C/C++ headers
        self.install_lib = None  # set to either purelib or platlib
        self.install_scripts = None
        self.install_data = None
        self.install_base = None
        self.install_platbase = None
        self.install_userbase = site.USER_BASE
        self.install_usersite = site.USER_SITE
        self.no_find_links = None

        # Options not specifiable via command line
        self.package_index = None
        self.pth_file = self.always_copy_from = None
        self.site_dirs = None
        self.installed_projects = {}
        # Always read easy_install options, even if we are subclassed, or have
        # an independent instance created.  This ensures that defaults will
        # always come from the standard configuration file(s)' "easy_install"
        # section, even if this is a "develop" or "install" command, or some
        # other embedding.
        self._dry_run = None
        self.verbose = self.distribution.verbose
        self.distribution._set_command_options(
            self, self.distribution.get_option_dict('easy_install')
        )

    def delete_blockers(self, blockers):
        extant_blockers = (
            filename
            for filename in blockers
            if os.path.exists(filename) or os.path.islink(filename)
        )
        list(map(self._delete_path, extant_blockers))

    def _delete_path(self, path):
        log.info("Deleting %s", path)
        if self.dry_run:
            return

        is_tree = os.path.isdir(path) and not os.path.islink(path)
        remover = _rmtree if is_tree else os.unlink
        remover(path)

    @staticmethod
    def _render_version():
        """
        Render the Setuptools version and installation details, then exit.
        """
        ver = '{}.{}'.format(*sys.version_info)
        dist = get_distribution('setuptools')
        tmpl = 'setuptools {dist.version} from {dist.location} (Python {ver})'
        print(tmpl.format(**locals()))
        raise SystemExit()

    def finalize_options(self):  # noqa: C901  # is too complex (25)  # FIXME
        self.version and self._render_version()

        py_version = sys.version.split()[0]

        self.config_vars = dict(sysconfig.get_config_vars())

        self.config_vars.update(
            {
                'dist_name': self.distribution.get_name(),
                'dist_version': self.distribution.get_version(),
                'dist_fullname': self.distribution.get_fullname(),
                'py_version': py_version,
                'py_version_short': (
                    f'{sys.version_info.major}.{sys.version_info.minor}'
                ),
                'py_version_nodot': f'{sys.version_info.major}{sys.version_info.minor}',
                'sys_prefix': self.config_vars['prefix'],
                'sys_exec_prefix': self.config_vars['exec_prefix'],
                # Only python 3.2+ has abiflags
                'abiflags': getattr(sys, 'abiflags', ''),
                'platlibdir': getattr(sys, 'platlibdir', 'lib'),
            }
        )
        with contextlib.suppress(AttributeError):
            # only for distutils outside stdlib
            self.config_vars.update(
                {
                    'implementation_lower': install._get_implementation().lower(),
                    'implementation': install._get_implementation(),
                }
            )

        # pypa/distutils#113 Python 3.9 compat
        self.config_vars.setdefault(
            'py_version_nodot_plat',
            getattr(sys, 'windir', '').replace('.', ''),
        )

        self.config_vars['userbase'] = self.install_userbase
        self.config_vars['usersite'] = self.install_usersite
        if self.user and not site.ENABLE_USER_SITE:
            log.warn("WARNING: The user site-packages directory is disabled.")

        self._fix_install_dir_for_user_site()

        self.expand_basedirs()
        self.expand_dirs()

        self._expand(
            'install_dir',
            'script_dir',
            'build_directory',
            'site_dirs',
        )
        # If a non-default installation directory was specified, default the
        # script directory to match it.
        if self.script_dir is None:
            self.script_dir = self.install_dir

        if self.no_find_links is None:
            self.no_find_links = False

        # Let install_dir get set by install_lib command, which in turn
        # gets its info from the install command, and takes into account
        # --prefix and --home and all that other crud.
        self.set_undefined_options('install_lib', ('install_dir', 'install_dir'))
        # Likewise, set default script_dir from 'install_scripts.install_dir'
        self.set_undefined_options('install_scripts', ('install_dir', 'script_dir'))

        if self.user and self.install_purelib:
            self.install_dir = self.install_purelib
            self.script_dir = self.install_scripts
        # default --record from the install command
        self.set_undefined_options('install', ('record', 'record'))
        self.all_site_dirs = get_site_dirs()
        self.all_site_dirs.extend(self._process_site_dirs(self.site_dirs))

        if not self.editable:
            self.check_site_dir()
        default_index = os.getenv("__EASYINSTALL_INDEX", "https://pypi.org/simple/")
        # ^ Private API for testing purposes only
        self.index_url = self.index_url or default_index
        self.shadow_path = self.all_site_dirs[:]
        for path_item in self.install_dir, normalize_path(self.script_dir):
            if path_item not in self.shadow_path:
                self.shadow_path.insert(0, path_item)

        if self.allow_hosts is not None:
            hosts = [s.strip() for s in self.allow_hosts.split(',')]
        else:
            hosts = ['*']
        if self.package_index is None:
            self.package_index = self.create_index(
                self.index_url,
                search_path=self.shadow_path,
                hosts=hosts,
            )
        self.local_index = Environment(self.shadow_path + sys.path)

        if self.find_links is not None:
            if isinstance(self.find_links, str):
                self.find_links = self.find_links.split()
        else:
            self.find_links = []
        if self.local_snapshots_ok:
            self.package_index.scan_egg_links(self.shadow_path + sys.path)
        if not self.no_find_links:
            self.package_index.add_find_links(self.find_links)
        self.set_undefined_options('install_lib', ('optimize', 'optimize'))
        self.optimize = self._validate_optimize(self.optimize)

        if self.editable and not self.build_directory:
            raise DistutilsArgError(
                "Must specify a build directory (-b) when using --editable"
            )
        if not self.args:
            raise DistutilsArgError(
                "No urls, filenames, or requirements specified (see --help)"
            )

        self.outputs = []

    @staticmethod
    def _process_site_dirs(site_dirs):
        if site_dirs is None:
            return

        normpath = map(normalize_path, sys.path)
        site_dirs = [os.path.expanduser(s.strip()) for s in site_dirs.split(',')]
        for d in site_dirs:
            if not os.path.isdir(d):
                log.warn("%s (in --site-dirs) does not exist", d)
            elif normalize_path(d) not in normpath:
                raise DistutilsOptionError(d + " (in --site-dirs) is not on sys.path")
            else:
                yield normalize_path(d)

    @staticmethod
    def _validate_optimize(value):
        try:
            value = int(value)
            if value not in range(3):
                raise ValueError
        except ValueError as e:
            raise DistutilsOptionError("--optimize must be 0, 1, or 2") from e

        return value

    def _fix_install_dir_for_user_site(self):
        """
        Fix the install_dir if "--user" was used.
        """
        if not self.user:
            return

        self.create_home_path()
        if self.install_userbase is None:
            msg = "User base directory is not specified"
            raise DistutilsPlatformError(msg)
        self.install_base = self.install_platbase = self.install_userbase
        scheme_name = f'{os.name}_user'
        self.select_scheme(scheme_name)

    def _expand_attrs(self, attrs):
        for attr in attrs:
            val = getattr(self, attr)
            if val is not None:
                if os.name == 'posix' or os.name == 'nt':
                    val = os.path.expanduser(val)
                val = subst_vars(val, self.config_vars)
                setattr(self, attr, val)

    def expand_basedirs(self):
        """Calls `os.path.expanduser` on install_base, install_platbase and
        root."""
        self._expand_attrs(['install_base', 'install_platbase', 'root'])

    def expand_dirs(self):
        """Calls `os.path.expanduser` on install dirs."""
        dirs = [
            'install_purelib',
            'install_platlib',
            'install_lib',
            'install_headers',
            'install_scripts',
            'install_data',
        ]
        self._expand_attrs(dirs)

    def run(self, show_deprecation=True):
        if show_deprecation:
            self.announce(
                "WARNING: The easy_install command is deprecated "
                "and will be removed in a future version.",
                log.WARN,
            )
        if self.verbose != self.distribution.verbose:
            log.set_verbosity(self.verbose)
        try:
            for spec in self.args:
                self.easy_install(spec, not self.no_deps)
            if self.record:
                outputs = self.outputs
                if self.root:  # strip any package prefix
                    root_len = len(self.root)
                    for counter in range(len(outputs)):
                        outputs[counter] = outputs[counter][root_len:]
                from distutils import file_util

                self.execute(
                    file_util.write_file,
                    (self.record, outputs),
                    "writing list of installed files to '%s'" % self.record,
                )
            self.warn_deprecated_options()
        finally:
            log.set_verbosity(self.distribution.verbose)

    def pseudo_tempname(self):
        """Return a pseudo-tempname base in the install directory.
        This code is intentionally naive; if a malicious party can write to
        the target directory you're already in deep doodoo.
        """
        try:
            pid = os.getpid()
        except Exception:
            pid = random.randint(0, sys.maxsize)
        return os.path.join(self.install_dir, "test-easy-install-%s" % pid)

    def warn_deprecated_options(self):
        pass

    def check_site_dir(self):  # noqa: C901  # is too complex (12)  # FIXME
        """Verify that self.install_dir is .pth-capable dir, if needed"""

        instdir = normalize_path(self.install_dir)
        pth_file = os.path.join(instdir, 'easy-install.pth')

        if not os.path.exists(instdir):
            try:
                os.makedirs(instdir)
            except (OSError, IOError):
                self.cant_write_to_target()

        # Is it a configured, PYTHONPATH, implicit, or explicit site dir?
        is_site_dir = instdir in self.all_site_dirs

        if not is_site_dir and not self.multi_version:
            # No?  Then directly test whether it does .pth file processing
            is_site_dir = self.check_pth_processing()
        else:
            # make sure we can write to target dir
            testfile = self.pseudo_tempname() + '.write-test'
            test_exists = os.path.exists(testfile)
            try:
                if test_exists:
                    os.unlink(testfile)
                open(testfile, 'w').close()
                os.unlink(testfile)
            except (OSError, IOError):
                self.cant_write_to_target()

        if not is_site_dir and not self.multi_version:
            # Can't install non-multi to non-site dir with easy_install
            pythonpath = os.environ.get('PYTHONPATH', '')
            log.warn(self.__no_default_msg, self.install_dir, pythonpath)

        if is_site_dir:
            if self.pth_file is None:
                self.pth_file = PthDistributions(pth_file, self.all_site_dirs)
        else:
            self.pth_file = None

        if self.multi_version and not os.path.exists(pth_file):
            self.pth_file = None  # don't create a .pth file
        self.install_dir = instdir

    __cant_write_msg = textwrap.dedent(
        """
        can't create or remove files in install directory

        The following error occurred while trying to add or remove files in the
        installation directory:

            %s

        The installation directory you specified (via --install-dir, --prefix, or
        the distutils default setting) was:

            %s
        """
    ).lstrip()  # noqa

    __not_exists_id = textwrap.dedent(
        """
        This directory does not currently exist.  Please create it and try again, or
        choose a different installation directory (using the -d or --install-dir
        option).
        """
    ).lstrip()  # noqa

    __access_msg = textwrap.dedent(
        """
        Perhaps your account does not have write access to this directory?  If the
        installation directory is a system-owned directory, you may need to sign in
        as the administrator or "root" account.  If you do not have administrative
        access to this machine, you may wish to choose a different installation
        directory, preferably one that is listed in your PYTHONPATH environment
        variable.

        For information on other options, you may wish to consult the
        documentation at:

          https://setuptools.pypa.io/en/latest/deprecated/easy_install.html

        Please make the appropriate changes for your system and try again.
        """
    ).lstrip()  # noqa

    def cant_write_to_target(self):
        msg = self.__cant_write_msg % (
            sys.exc_info()[1],
            self.install_dir,
        )

        if not os.path.exists(self.install_dir):
            msg += '\n' + self.__not_exists_id
        else:
            msg += '\n' + self.__access_msg
        raise DistutilsError(msg)

    def check_pth_processing(self):
        """Empirically verify whether .pth files are supported in inst. dir"""
        instdir = self.install_dir
        log.info("Checking .pth file support in %s", instdir)
        pth_file = self.pseudo_tempname() + ".pth"
        ok_file = pth_file + '.ok'
        ok_exists = os.path.exists(ok_file)
        tmpl = (
            _one_liner(
                """
            import os
            f = open({ok_file!r}, 'w')
            f.write('OK')
            f.close()
            """
            )
            + '\n'
        )
        try:
            if ok_exists:
                os.unlink(ok_file)
            dirname = os.path.dirname(ok_file)
            os.makedirs(dirname, exist_ok=True)
            f = open(pth_file, 'w')
        except (OSError, IOError):
            self.cant_write_to_target()
        else:
            try:
                f.write(tmpl.format(**locals()))
                f.close()
                f = None
                executable = sys.executable
                if os.name == 'nt':
                    dirname, basename = os.path.split(executable)
                    alt = os.path.join(dirname, 'pythonw.exe')
                    use_alt = basename.lower() == 'python.exe' and os.path.exists(alt)
                    if use_alt:
                        # use pythonw.exe to avoid opening a console window
                        executable = alt

                from distutils.spawn import spawn

                spawn([executable, '-E', '-c', 'pass'], 0)

                if os.path.exists(ok_file):
                    log.info("TEST PASSED: %s appears to support .pth files", instdir)
                    return True
            finally:
                if f:
                    f.close()
                if os.path.exists(ok_file):
                    os.unlink(ok_file)
                if os.path.exists(pth_file):
                    os.unlink(pth_file)
        if not self.multi_version:
            log.warn("TEST FAILED: %s does NOT support .pth files", instdir)
        return False

    def install_egg_scripts(self, dist):
        """Write all the scripts for `dist`, unless scripts are excluded"""
        if not self.exclude_scripts and dist.metadata_isdir('scripts'):
            for script_name in dist.metadata_listdir('scripts'):
                if dist.metadata_isdir('scripts/' + script_name):
                    # The "script" is a directory, likely a Python 3
                    # __pycache__ directory, so skip it.
                    continue
                self.install_script(
                    dist, script_name, dist.get_metadata('scripts/' + script_name)
                )
        self.install_wrapper_scripts(dist)

    def add_output(self, path):
        if os.path.isdir(path):
            for base, dirs, files in os.walk(path):
                for filename in files:
                    self.outputs.append(os.path.join(base, filename))
        else:
            self.outputs.append(path)

    def not_editable(self, spec):
        if self.editable:
            raise DistutilsArgError(
                "Invalid argument %r: you can't use filenames or URLs "
                "with --editable (except via the --find-links option)." % (spec,)
            )

    def check_editable(self, spec):
        if not self.editable:
            return

        if os.path.exists(os.path.join(self.build_directory, spec.key)):
            raise DistutilsArgError(
                "%r already exists in %s; can't do a checkout there"
                % (spec.key, self.build_directory)
            )

    @contextlib.contextmanager
    def _tmpdir(self):
        tmpdir = tempfile.mkdtemp(prefix=u"easy_install-")
        try:
            # cast to str as workaround for #709 and #710 and #712
            yield str(tmpdir)
        finally:
            os.path.exists(tmpdir) and _rmtree(tmpdir)

    def easy_install(self, spec, deps=False):
        with self._tmpdir() as tmpdir:
            if not isinstance(spec, Requirement):
                if URL_SCHEME(spec):
                    # It's a url, download it to tmpdir and process
                    self.not_editable(spec)
                    dl = self.package_index.download(spec, tmpdir)
                    return self.install_item(None, dl, tmpdir, deps, True)

                elif os.path.exists(spec):
                    # Existing file or directory, just process it directly
                    self.not_editable(spec)
                    return self.install_item(None, spec, tmpdir, deps, True)
                else:
                    spec = parse_requirement_arg(spec)

            self.check_editable(spec)
            dist = self.package_index.fetch_distribution(
                spec,
                tmpdir,
                self.upgrade,
                self.editable,
                not self.always_copy,
                self.local_index,
            )
            if dist is None:
                msg = "Could not find suitable distribution for %r" % spec
                if self.always_copy:
                    msg += " (--always-copy skips system and development eggs)"
                raise DistutilsError(msg)
            elif dist.precedence == DEVELOP_DIST:
                # .egg-info dists don't need installing, just process deps
                self.process_distribution(spec, dist, deps, "Using")
                return dist
            else:
                return self.install_item(spec, dist.location, tmpdir, deps)

    def install_item(self, spec, download, tmpdir, deps, install_needed=False):
        # Installation is also needed if file in tmpdir or is not an egg
        install_needed = install_needed or self.always_copy
        install_needed = install_needed or os.path.dirname(download) == tmpdir
        install_needed = install_needed or not download.endswith('.egg')
        install_needed = install_needed or (
            self.always_copy_from is not None
            and os.path.dirname(normalize_path(download))
            == normalize_path(self.always_copy_from)
        )

        if spec and not install_needed:
            # at this point, we know it's a local .egg, we just don't know if
            # it's already installed.
            for dist in self.local_index[spec.project_name]:
                if dist.location == download:
                    break
            else:
                install_needed = True  # it's not in the local index

        log.info("Processing %s", os.path.basename(download))

        if install_needed:
            dists = self.install_eggs(spec, download, tmpdir)
            for dist in dists:
                self.process_distribution(spec, dist, deps)
        else:
            dists = [self.egg_distribution(download)]
            self.process_distribution(spec, dists[0], deps, "Using")

        if spec is not None:
            for dist in dists:
                if dist in spec:
                    return dist

    def select_scheme(self, name):
        try:
            install._select_scheme(self, name)
        except AttributeError:
            # stdlib distutils
            install.install.select_scheme(self, name.replace('posix', 'unix'))

    # FIXME: 'easy_install.process_distribution' is too complex (12)
    def process_distribution(  # noqa: C901
        self,
        requirement,
        dist,
        deps=True,
        *info,
    ):
        self.update_pth(dist)
        self.package_index.add(dist)
        if dist in self.local_index[dist.key]:
            self.local_index.remove(dist)
        self.local_index.add(dist)
        self.install_egg_scripts(dist)
        self.installed_projects[dist.key] = dist
        log.info(self.installation_report(requirement, dist, *info))
        if dist.has_metadata('dependency_links.txt') and not self.no_find_links:
            self.package_index.add_find_links(
                dist.get_metadata_lines('dependency_links.txt')
            )
        if not deps and not self.always_copy:
            return
        elif requirement is not None and dist.key != requirement.key:
            log.warn("Skipping dependencies for %s", dist)
            return  # XXX this is not the distribution we were looking for
        elif requirement is None or dist not in requirement:
            # if we wound up with a different version, resolve what we've got
            distreq = dist.as_requirement()
            requirement = Requirement(str(distreq))
        log.info("Processing dependencies for %s", requirement)
        try:
            distros = WorkingSet([]).resolve(
                [requirement], self.local_index, self.easy_install
            )
        except DistributionNotFound as e:
            raise DistutilsError(str(e)) from e
        except VersionConflict as e:
            raise DistutilsError(e.report()) from e
        if self.always_copy or self.always_copy_from:
            # Force all the relevant distros to be copied or activated
            for dist in distros:
                if dist.key not in self.installed_projects:
                    self.easy_install(dist.as_requirement())
        log.info("Finished processing dependencies for %s", requirement)

    def should_unzip(self, dist):
        if self.zip_ok is not None:
            return not self.zip_ok
        if dist.has_metadata('not-zip-safe'):
            return True
        if not dist.has_metadata('zip-safe'):
            return True
        return False

    def maybe_move(self, spec, dist_filename, setup_base):
        dst = os.path.join(self.build_directory, spec.key)
        if os.path.exists(dst):
            msg = "%r already exists in %s; build directory %s will not be kept"
            log.warn(msg, spec.key, self.build_directory, setup_base)
            return setup_base
        if os.path.isdir(dist_filename):
            setup_base = dist_filename
        else:
            if os.path.dirname(dist_filename) == setup_base:
                os.unlink(dist_filename)  # get it out of the tmp dir
            contents = os.listdir(setup_base)
            if len(contents) == 1:
                dist_filename = os.path.join(setup_base, contents[0])
                if os.path.isdir(dist_filename):
                    # if the only thing there is a directory, move it instead
                    setup_base = dist_filename
        ensure_directory(dst)
        shutil.move(setup_base, dst)
        return dst

    def install_wrapper_scripts(self, dist):
        if self.exclude_scripts:
            return
        for args in ScriptWriter.best().get_args(dist):
            self.write_script(*args)

    def install_script(self, dist, script_name, script_text, dev_path=None):
        """Generate a legacy script wrapper and install it"""
        spec = str(dist.as_requirement())
        is_script = is_python_script(script_text, script_name)

        if is_script:
            body = self._load_template(dev_path) % locals()
            script_text = ScriptWriter.get_header(script_text) + body
        self.write_script(script_name, _to_bytes(script_text), 'b')

    @staticmethod
    def _load_template(dev_path):
        """
        There are a couple of template scripts in the package. This
        function loads one of them and prepares it for use.
        """
        # See https://github.com/pypa/setuptools/issues/134 for info
        # on script file naming and downstream issues with SVR4
        name = 'script.tmpl'
        if dev_path:
            name = name.replace('.tmpl', ' (dev).tmpl')

        raw_bytes = resource_string('setuptools', name)
        return raw_bytes.decode('utf-8')

    def write_script(self, script_name, contents, mode="t", blockers=()):
        """Write an executable file to the scripts directory"""
        self.delete_blockers(  # clean up old .py/.pyw w/o a script
            [os.path.join(self.script_dir, x) for x in blockers]
        )
        log.info("Installing %s script to %s", script_name, self.script_dir)
        target = os.path.join(self.script_dir, script_name)
        self.add_output(target)

        if self.dry_run:
            return

        mask = current_umask()
        ensure_directory(target)
        if os.path.exists(target):
            os.unlink(target)
        with open(target, "w" + mode) as f:
            f.write(contents)
        chmod(target, 0o777 - mask)

    def install_eggs(self, spec, dist_filename, tmpdir):
        # .egg dirs or files are already built, so just return them
        installer_map = {
            '.egg': self.install_egg,
            '.exe': self.install_exe,
            '.whl': self.install_wheel,
        }
        try:
            install_dist = installer_map[dist_filename.lower()[-4:]]
        except KeyError:
            pass
        else:
            return [install_dist(dist_filename, tmpdir)]

        # Anything else, try to extract and build
        setup_base = tmpdir
        if os.path.isfile(dist_filename) and not dist_filename.endswith('.py'):
            unpack_archive(dist_filename, tmpdir, self.unpack_progress)
        elif os.path.isdir(dist_filename):
            setup_base = os.path.abspath(dist_filename)

        if (
            setup_base.startswith(tmpdir)  # something we downloaded
            and self.build_directory
            and spec is not None
        ):
            setup_base = self.maybe_move(spec, dist_filename, setup_base)

        # Find the setup.py file
        setup_script = os.path.join(setup_base, 'setup.py')

        if not os.path.exists(setup_script):
            setups = glob(os.path.join(setup_base, '*', 'setup.py'))
            if not setups:
                raise DistutilsError(
                    "Couldn't find a setup script in %s"
                    % os.path.abspath(dist_filename)
                )
            if len(setups) > 1:
                raise DistutilsError(
                    "Multiple setup scripts in %s" % os.path.abspath(dist_filename)
                )
            setup_script = setups[0]

        # Now run it, and return the result
        if self.editable:
            log.info(self.report_editable(spec, setup_script))
            return []
        else:
            return self.build_and_install(setup_script, setup_base)

    def egg_distribution(self, egg_path):
        if os.path.isdir(egg_path):
            metadata = PathMetadata(egg_path, os.path.join(egg_path, 'EGG-INFO'))
        else:
            metadata = EggMetadata(zipimport.zipimporter(egg_path))
        return Distribution.from_filename(egg_path, metadata=metadata)

    # FIXME: 'easy_install.install_egg' is too complex (11)
    def install_egg(self, egg_path, tmpdir):  # noqa: C901
        destination = os.path.join(
            self.install_dir,
            os.path.basename(egg_path),
        )
        destination = os.path.abspath(destination)
        if not self.dry_run:
            ensure_directory(destination)

        dist = self.egg_distribution(egg_path)
        if not (
            os.path.exists(destination) and os.path.samefile(egg_path, destination)
        ):
            if os.path.isdir(destination) and not os.path.islink(destination):
                dir_util.remove_tree(destination, dry_run=self.dry_run)
            elif os.path.exists(destination):
                self.execute(
                    os.unlink,
                    (destination,),
                    "Removing " + destination,
                )
            try:
                new_dist_is_zipped = False
                if os.path.isdir(egg_path):
                    if egg_path.startswith(tmpdir):
                        f, m = shutil.move, "Moving"
                    else:
                        f, m = shutil.copytree, "Copying"
                elif self.should_unzip(dist):
                    self.mkpath(destination)
                    f, m = self.unpack_and_compile, "Extracting"
                else:
                    new_dist_is_zipped = True
                    if egg_path.startswith(tmpdir):
                        f, m = shutil.move, "Moving"
                    else:
                        f, m = shutil.copy2, "Copying"
                self.execute(
                    f,
                    (egg_path, destination),
                    (m + " %s to %s")
                    % (os.path.basename(egg_path), os.path.dirname(destination)),
                )
                update_dist_caches(
                    destination,
                    fix_zipimporter_caches=new_dist_is_zipped,
                )
            except Exception:
                update_dist_caches(destination, fix_zipimporter_caches=False)
                raise

        self.add_output(destination)
        return self.egg_distribution(destination)

    def install_exe(self, dist_filename, tmpdir):
        # See if it's valid, get data
        cfg = extract_wininst_cfg(dist_filename)
        if cfg is None:
            raise DistutilsError(
                "%s is not a valid distutils Windows .exe" % dist_filename
            )
        # Create a dummy distribution object until we build the real distro
        dist = Distribution(
            None,
            project_name=cfg.get('metadata', 'name'),
            version=cfg.get('metadata', 'version'),
            platform=get_platform(),
        )

        # Convert the .exe to an unpacked egg
        egg_path = os.path.join(tmpdir, dist.egg_name() + '.egg')
        dist.location = egg_path
        egg_tmp = egg_path + '.tmp'
        _egg_info = os.path.join(egg_tmp, 'EGG-INFO')
        pkg_inf = os.path.join(_egg_info, 'PKG-INFO')
        ensure_directory(pkg_inf)  # make sure EGG-INFO dir exists
        dist._provider = PathMetadata(egg_tmp, _egg_info)  # XXX
        self.exe_to_egg(dist_filename, egg_tmp)

        # Write EGG-INFO/PKG-INFO
        if not os.path.exists(pkg_inf):
            f = open(pkg_inf, 'w')
            f.write('Metadata-Version: 1.0\n')
            for k, v in cfg.items('metadata'):
                if k != 'target_version':
                    f.write('%s: %s\n' % (k.replace('_', '-').title(), v))
            f.close()
        script_dir = os.path.join(_egg_info, 'scripts')
        # delete entry-point scripts to avoid duping
        self.delete_blockers(
            [os.path.join(script_dir, args[0]) for args in ScriptWriter.get_args(dist)]
        )
        # Build .egg file from tmpdir
        bdist_egg.make_zipfile(
            egg_path,
            egg_tmp,
            verbose=self.verbose,
            dry_run=self.dry_run,
        )
        # install the .egg
        return self.install_egg(egg_path, tmpdir)

    # FIXME: 'easy_install.exe_to_egg' is too complex (12)
    def exe_to_egg(self, dist_filename, egg_tmp):  # noqa: C901
        """Extract a bdist_wininst to the directories an egg would use"""
        # Check for .pth file and set up prefix translations
        prefixes = get_exe_prefixes(dist_filename)
        to_compile = []
        native_libs = []
        top_level = {}

        def process(src, dst):
            s = src.lower()
            for old, new in prefixes:
                if s.startswith(old):
                    src = new + src[len(old) :]
                    parts = src.split('/')
                    dst = os.path.join(egg_tmp, *parts)
                    dl = dst.lower()
                    if dl.endswith('.pyd') or dl.endswith('.dll'):
                        parts[-1] = bdist_egg.strip_module(parts[-1])
                        top_level[os.path.splitext(parts[0])[0]] = 1
                        native_libs.append(src)
                    elif dl.endswith('.py') and old != 'SCRIPTS/':
                        top_level[os.path.splitext(parts[0])[0]] = 1
                        to_compile.append(dst)
                    return dst
            if not src.endswith('.pth'):
                log.warn("WARNING: can't process %s", src)
            return None

        # extract, tracking .pyd/.dll->native_libs and .py -> to_compile
        unpack_archive(dist_filename, egg_tmp, process)
        stubs = []
        for res in native_libs:
            if res.lower().endswith('.pyd'):  # create stubs for .pyd's
                parts = res.split('/')
                resource = parts[-1]
                parts[-1] = bdist_egg.strip_module(parts[-1]) + '.py'
                pyfile = os.path.join(egg_tmp, *parts)
                to_compile.append(pyfile)
                stubs.append(pyfile)
                bdist_egg.write_stub(resource, pyfile)
        self.byte_compile(to_compile)  # compile .py's
        bdist_egg.write_safety_flag(
            os.path.join(egg_tmp, 'EGG-INFO'), bdist_egg.analyze_egg(egg_tmp, stubs)
        )  # write zip-safety flag

        for name in 'top_level', 'native_libs':
            if locals()[name]:
                txt = os.path.join(egg_tmp, 'EGG-INFO', name + '.txt')
                if not os.path.exists(txt):
                    f = open(txt, 'w')
                    f.write('\n'.join(locals()[name]) + '\n')
                    f.close()

    def install_wheel(self, wheel_path, tmpdir):
        wheel = Wheel(wheel_path)
        assert wheel.is_compatible()
        destination = os.path.join(self.install_dir, wheel.egg_name())
        destination = os.path.abspath(destination)
        if not self.dry_run:
            ensure_directory(destination)
        if os.path.isdir(destination) and not os.path.islink(destination):
            dir_util.remove_tree(destination, dry_run=self.dry_run)
        elif os.path.exists(destination):
            self.execute(
                os.unlink,
                (destination,),
                "Removing " + destination,
            )
        try:
            self.execute(
                wheel.install_as_egg,
                (destination,),
                ("Installing %s to %s")
                % (os.path.basename(wheel_path), os.path.dirname(destination)),
            )
        finally:
            update_dist_caches(destination, fix_zipimporter_caches=False)
        self.add_output(destination)
        return self.egg_distribution(destination)

    __mv_warning = textwrap.dedent(
        """
        Because this distribution was installed --multi-version, before you can
        import modules from this package in an application, you will need to
        'import pkg_resources' and then use a 'require()' call similar to one of
        these examples, in order to select the desired version:

            pkg_resources.require("%(name)s")  # latest installed version
            pkg_resources.require("%(name)s==%(version)s")  # this exact version
            pkg_resources.require("%(name)s>=%(version)s")  # this version or higher
        """
    ).lstrip()  # noqa

    __id_warning = textwrap.dedent(
        """
        Note also that the installation directory must be on sys.path at runtime for
        this to work.  (e.g. by being the application's script directory, by being on
        PYTHONPATH, or by being added to sys.path by your code.)
        """
    )  # noqa

    def installation_report(self, req, dist, what="Installed"):
        """Helpful installation message for display to package users"""
        msg = "\n%(what)s %(eggloc)s%(extras)s"
        if self.multi_version and not self.no_report:
            msg += '\n' + self.__mv_warning
            if self.install_dir not in map(normalize_path, sys.path):
                msg += '\n' + self.__id_warning

        eggloc = dist.location
        name = dist.project_name
        version = dist.version
        extras = ''  # TODO: self.report_extras(req, dist)
        return msg % locals()

    __editable_msg = textwrap.dedent(
        """
        Extracted editable version of %(spec)s to %(dirname)s

        If it uses setuptools in its setup script, you can activate it in
        "development" mode by going to that directory and running::

            %(python)s setup.py develop

        See the setuptools documentation for the "develop" command for more info.
        """
    ).lstrip()  # noqa

    def report_editable(self, spec, setup_script):
        dirname = os.path.dirname(setup_script)
        python = sys.executable
        return '\n' + self.__editable_msg % locals()

    def run_setup(self, setup_script, setup_base, args):
        sys.modules.setdefault('distutils.command.bdist_egg', bdist_egg)
        sys.modules.setdefault('distutils.command.egg_info', egg_info)

        args = list(args)
        if self.verbose > 2:
            v = 'v' * (self.verbose - 1)
            args.insert(0, '-' + v)
        elif self.verbose < 2:
            args.insert(0, '-q')
        if self.dry_run:
            args.insert(0, '-n')
        log.info("Running %s %s", setup_script[len(setup_base) + 1 :], ' '.join(args))
        try:
            run_setup(setup_script, args)
        except SystemExit as v:
            raise DistutilsError("Setup script exited with %s" % (v.args[0],)) from v

    def build_and_install(self, setup_script, setup_base):
        args = ['bdist_egg', '--dist-dir']

        dist_dir = tempfile.mkdtemp(
            prefix='egg-dist-tmp-', dir=os.path.dirname(setup_script)
        )
        try:
            self._set_fetcher_options(os.path.dirname(setup_script))
            args.append(dist_dir)

            self.run_setup(setup_script, setup_base, args)
            all_eggs = Environment([dist_dir])
            eggs = []
            for key in all_eggs:
                for dist in all_eggs[key]:
                    eggs.append(self.install_egg(dist.location, setup_base))
            if not eggs and not self.dry_run:
                log.warn("No eggs found in %s (setup script problem?)", dist_dir)
            return eggs
        finally:
            _rmtree(dist_dir)
            log.set_verbosity(self.verbose)  # restore our log verbosity

    def _set_fetcher_options(self, base):
        """
        When easy_install is about to run bdist_egg on a source dist, that
        source dist might have 'setup_requires' directives, requiring
        additional fetching. Ensure the fetcher options given to easy_install
        are available to that command as well.
        """
        # find the fetch options from easy_install and write them out
        # to the setup.cfg file.
        ei_opts = self.distribution.get_option_dict('easy_install').copy()
        fetch_directives = (
            'find_links',
            'site_dirs',
            'index_url',
            'optimize',
            'allow_hosts',
        )
        fetch_options = {}
        for key, val in ei_opts.items():
            if key not in fetch_directives:
                continue
            fetch_options[key] = val[1]
        # create a settings dictionary suitable for `edit_config`
        settings = dict(easy_install=fetch_options)
        cfg_filename = os.path.join(base, 'setup.cfg')
        setopt.edit_config(cfg_filename, settings)

    def update_pth(self, dist):  # noqa: C901  # is too complex (11)  # FIXME
        if self.pth_file is None:
            return

        for d in self.pth_file[dist.key]:  # drop old entries
            if not self.multi_version and d.location == dist.location:
                continue

            log.info("Removing %s from easy-install.pth file", d)
            self.pth_file.remove(d)
            if d.location in self.shadow_path:
                self.shadow_path.remove(d.location)

        if not self.multi_version:
            if dist.location in self.pth_file.paths:
                log.info(
                    "%s is already the active version in easy-install.pth",
                    dist,
                )
            else:
                log.info("Adding %s to easy-install.pth file", dist)
                self.pth_file.add(dist)  # add new entry
                if dist.location not in self.shadow_path:
                    self.shadow_path.append(dist.location)

        if self.dry_run:
            return

        self.pth_file.save()

        if dist.key != 'setuptools':
            return

        # Ensure that setuptools itself never becomes unavailable!
        # XXX should this check for latest version?
        filename = os.path.join(self.install_dir, 'setuptools.pth')
        if os.path.islink(filename):
            os.unlink(filename)
        with open(filename, 'wt') as f:
            f.write(self.pth_file.make_relative(dist.location) + '\n')

    def unpack_progress(self, src, dst):
        # Progress filter for unpacking
        log.debug("Unpacking %s to %s", src, dst)
        return dst  # only unpack-and-compile skips files for dry run

    def unpack_and_compile(self, egg_path, destination):
        to_compile = []
        to_chmod = []

        def pf(src, dst):
            if dst.endswith('.py') and not src.startswith('EGG-INFO/'):
                to_compile.append(dst)
            elif dst.endswith('.dll') or dst.endswith('.so'):
                to_chmod.append(dst)
            self.unpack_progress(src, dst)
            return not self.dry_run and dst or None

        unpack_archive(egg_path, destination, pf)
        self.byte_compile(to_compile)
        if not self.dry_run:
            for f in to_chmod:
                mode = ((os.stat(f)[stat.ST_MODE]) | 0o555) & 0o7755
                chmod(f, mode)

    def byte_compile(self, to_compile):
        if sys.dont_write_bytecode:
            return

        from distutils.util import byte_compile

        try:
            # try to make the byte compile messages quieter
            log.set_verbosity(self.verbose - 1)

            byte_compile(to_compile, optimize=0, force=1, dry_run=self.dry_run)
            if self.optimize:
                byte_compile(
                    to_compile,
                    optimize=self.optimize,
                    force=1,
                    dry_run=self.dry_run,
                )
        finally:
            log.set_verbosity(self.verbose)  # restore original verbosity

    __no_default_msg = textwrap.dedent(
        """
        bad install directory or PYTHONPATH

        You are attempting to install a package to a directory that is not
        on PYTHONPATH and which Python does not read ".pth" files from.  The
        installation directory you specified (via --install-dir, --prefix, or
        the distutils default setting) was:

            %s

        and your PYTHONPATH environment variable currently contains:

            %r

        Here are some of your options for correcting the problem:

        * You can choose a different installation directory, i.e., one that is
          on PYTHONPATH or supports .pth files

        * You can add the installation directory to the PYTHONPATH environment
          variable.  (It must then also be on PYTHONPATH whenever you run
          Python and want to use the package(s) you are installing.)

        * You can set up the installation directory to support ".pth" files by
          using one of the approaches described here:

          https://setuptools.pypa.io/en/latest/deprecated/easy_install.html#custom-installation-locations


        Please make the appropriate changes for your system and try again.
        """
    ).strip()

    def create_home_path(self):
        """Create directories under ~."""
        if not self.user:
            return
        home = convert_path(os.path.expanduser("~"))
        for path in only_strs(self.config_vars.values()):
            if path.startswith(home) and not os.path.isdir(path):
                self.debug_print("os.makedirs('%s', 0o700)" % path)
                os.makedirs(path, 0o700)

    INSTALL_SCHEMES = dict(
        posix=dict(
            install_dir='$base/lib/python$py_version_short/site-packages',
            script_dir='$base/bin',
        ),
    )

    DEFAULT_SCHEME = dict(
        install_dir='$base/Lib/site-packages',
        script_dir='$base/Scripts',
    )

    def _expand(self, *attrs):
        config_vars = self.get_finalized_command('install').config_vars

        if self.prefix:
            # Set default install_dir/scripts from --prefix
            config_vars = dict(config_vars)
            config_vars['base'] = self.prefix
            scheme = self.INSTALL_SCHEMES.get(os.name, self.DEFAULT_SCHEME)
            for attr, val in scheme.items():
                if getattr(self, attr, None) is None:
                    setattr(self, attr, val)

        from distutils.util import subst_vars

        for attr in attrs:
            val = getattr(self, attr)
            if val is not None:
                val = subst_vars(val, config_vars)
                if os.name == 'posix':
                    val = os.path.expanduser(val)
                setattr(self, attr, val)


def _pythonpath():
    items = os.environ.get('PYTHONPATH', '').split(os.pathsep)
    return filter(None, items)


def get_site_dirs():
    """
    Return a list of 'site' dirs
    """

    sitedirs = []

    # start with PYTHONPATH
    sitedirs.extend(_pythonpath())

    prefixes = [sys.prefix]
    if sys.exec_prefix != sys.prefix:
        prefixes.append(sys.exec_prefix)
    for prefix in prefixes:
        if not prefix:
            continue

        if sys.platform in ('os2emx', 'riscos'):
            sitedirs.append(os.path.join(prefix, "Lib", "site-packages"))
        elif os.sep == '/':
            sitedirs.extend(
                [
                    os.path.join(
                        prefix,
                        "lib",
                        "python{}.{}".format(*sys.version_info),
                        "site-packages",
                    ),
                    os.path.join(prefix, "lib", "site-python"),
                ]
            )
        else:
            sitedirs.extend(
                [
                    prefix,
                    os.path.join(prefix, "lib", "site-packages"),
                ]
            )
        if sys.platform != 'darwin':
            continue

        # for framework builds *only* we add the standard Apple
        # locations. Currently only per-user, but /Library and
        # /Network/Library could be added too
        if 'Python.framework' not in prefix:
            continue

        home = os.environ.get('HOME')
        if not home:
            continue

        home_sp = os.path.join(
            home,
            'Library',
            'Python',
            '{}.{}'.format(*sys.version_info),
            'site-packages',
        )
        sitedirs.append(home_sp)
    lib_paths = get_path('purelib'), get_path('platlib')

    sitedirs.extend(s for s in lib_paths if s not in sitedirs)

    if site.ENABLE_USER_SITE:
        sitedirs.append(site.USER_SITE)

    with contextlib.suppress(AttributeError):
        sitedirs.extend(site.getsitepackages())

    sitedirs = list(map(normalize_path, sitedirs))

    return sitedirs


def expand_paths(inputs):  # noqa: C901  # is too complex (11)  # FIXME
    """Yield sys.path directories that might contain "old-style" packages"""

    seen = {}

    for dirname in inputs:
        dirname = normalize_path(dirname)
        if dirname in seen:
            continue

        seen[dirname] = 1
        if not os.path.isdir(dirname):
            continue

        files = os.listdir(dirname)
        yield dirname, files

        for name in files:
            if not name.endswith('.pth'):
                # We only care about the .pth files
                continue
            if name in ('easy-install.pth', 'setuptools.pth'):
                # Ignore .pth files that we control
                continue

            # Read the .pth file
            f = open(os.path.join(dirname, name))
            lines = list(yield_lines(f))
            f.close()

            # Yield existing non-dupe, non-import directory lines from it
            for line in lines:
                if line.startswith("import"):
                    continue

                line = normalize_path(line.rstrip())
                if line in seen:
                    continue

                seen[line] = 1
                if not os.path.isdir(line):
                    continue

                yield line, os.listdir(line)


def extract_wininst_cfg(dist_filename):
    """Extract configuration data from a bdist_wininst .exe

    Returns a configparser.RawConfigParser, or None
    """
    f = open(dist_filename, 'rb')
    try:
        endrec = zipfile._EndRecData(f)
        if endrec is None:
            return None

        prepended = (endrec[9] - endrec[5]) - endrec[6]
        if prepended < 12:  # no wininst data here
            return None
        f.seek(prepended - 12)

        tag, cfglen, bmlen = struct.unpack("egg path translations for a given .exe file"""

    prefixes = [
        ('PURELIB/', ''),
        ('PLATLIB/pywin32_system32', ''),
        ('PLATLIB/', ''),
        ('SCRIPTS/', 'EGG-INFO/scripts/'),
        ('DATA/lib/site-packages', ''),
    ]
    z = zipfile.ZipFile(exe_filename)
    try:
        for info in z.infolist():
            name = info.filename
            parts = name.split('/')
            if len(parts) == 3 and parts[2] == 'PKG-INFO':
                if parts[1].endswith('.egg-info'):
                    prefixes.insert(0, ('/'.join(parts[:2]), 'EGG-INFO/'))
                    break
            if len(parts) != 2 or not name.endswith('.pth'):
                continue
            if name.endswith('-nspkg.pth'):
                continue
            if parts[0].upper() in ('PURELIB', 'PLATLIB'):
                contents = z.read(name).decode()
                for pth in yield_lines(contents):
                    pth = pth.strip().replace('\\', '/')
                    if not pth.startswith('import'):
                        prefixes.append((('%s/%s/' % (parts[0], pth)), ''))
    finally:
        z.close()
    prefixes = [(x.lower(), y) for x, y in prefixes]
    prefixes.sort()
    prefixes.reverse()
    return prefixes


class PthDistributions(Environment):
    """A .pth file with Distribution paths in it"""

    def __init__(self, filename, sitedirs=()):
        self.filename = filename
        self.sitedirs = list(map(normalize_path, sitedirs))
        self.basedir = normalize_path(os.path.dirname(self.filename))
        self.paths, self.dirty = self._load()
        # keep a copy if someone manually updates the paths attribute on the instance
        self._init_paths = self.paths[:]
        super().__init__([], None, None)
        for path in yield_lines(self.paths):
            list(map(self.add, find_distributions(path, True)))

    def _load_raw(self):
        paths = []
        dirty = saw_import = False
        seen = dict.fromkeys(self.sitedirs)
        f = open(self.filename, 'rt')
        for line in f:
            path = line.rstrip()
            # still keep imports and empty/commented lines for formatting
            paths.append(path)
            if line.startswith(('import ', 'from ')):
                saw_import = True
                continue
            stripped_path = path.strip()
            if not stripped_path or stripped_path.startswith('#'):
                continue
            # skip non-existent paths, in case somebody deleted a package
            # manually, and duplicate paths as well
            normalized_path = normalize_path(os.path.join(self.basedir, path))
            if normalized_path in seen or not os.path.exists(normalized_path):
                log.debug("cleaned up dirty or duplicated %r", path)
                dirty = True
                paths.pop()
                continue
            seen[normalized_path] = 1
        f.close()
        # remove any trailing empty/blank line
        while paths and not paths[-1].strip():
            paths.pop()
            dirty = True
        return paths, dirty or (paths and saw_import)

    def _load(self):
        if os.path.isfile(self.filename):
            return self._load_raw()
        return [], False

    def save(self):
        """Write changed .pth file back to disk"""
        # first reload the file
        last_paths, last_dirty = self._load()
        # and check that there are no difference with what we have.
        # there can be difference if someone else has written to the file
        # since we first loaded it.
        # we don't want to lose the eventual new paths added since then.
        for path in last_paths[:]:
            if path not in self.paths:
                self.paths.append(path)
                log.info("detected new path %r", path)
                last_dirty = True
            else:
                last_paths.remove(path)
        # also, re-check that all paths are still valid before saving them
        for path in self.paths[:]:
            if path not in last_paths and not path.startswith(
                ('import ', 'from ', '#')
            ):
                absolute_path = os.path.join(self.basedir, path)
                if not os.path.exists(absolute_path):
                    self.paths.remove(path)
                    log.info("removing now non-existent path %r", path)
                    last_dirty = True

        self.dirty |= last_dirty or self.paths != self._init_paths
        if not self.dirty:
            return

        rel_paths = list(map(self.make_relative, self.paths))
        if rel_paths:
            log.debug("Saving %s", self.filename)
            lines = self._wrap_lines(rel_paths)
            data = '\n'.join(lines) + '\n'
            if os.path.islink(self.filename):
                os.unlink(self.filename)
            with open(self.filename, 'wt') as f:
                f.write(data)
        elif os.path.exists(self.filename):
            log.debug("Deleting empty %s", self.filename)
            os.unlink(self.filename)

        self.dirty = False
        self._init_paths[:] = self.paths[:]

    @staticmethod
    def _wrap_lines(lines):
        return lines

    def add(self, dist):
        """Add `dist` to the distribution map"""
        new_path = dist.location not in self.paths and (
            dist.location not in self.sitedirs
            or
            # account for '.' being in PYTHONPATH
            dist.location == os.getcwd()
        )
        if new_path:
            self.paths.append(dist.location)
            self.dirty = True
        super().add(dist)

    def remove(self, dist):
        """Remove `dist` from the distribution map"""
        while dist.location in self.paths:
            self.paths.remove(dist.location)
            self.dirty = True
        super().remove(dist)

    def make_relative(self, path):
        npath, last = os.path.split(normalize_path(path))
        baselen = len(self.basedir)
        parts = [last]
        sep = os.altsep == '/' and '/' or os.sep
        while len(npath) >= baselen:
            if npath == self.basedir:
                parts.append(os.curdir)
                parts.reverse()
                return sep.join(parts)
            npath, last = os.path.split(npath)
            parts.append(last)
        else:
            return path


class RewritePthDistributions(PthDistributions):
    @classmethod
    def _wrap_lines(cls, lines):
        yield cls.prelude
        for line in lines:
            yield line
        yield cls.postlude

    prelude = _one_liner(
        """
        import sys
        sys.__plen = len(sys.path)
        """
    )
    postlude = _one_liner(
        """
        import sys
        new = sys.path[sys.__plen:]
        del sys.path[sys.__plen:]
        p = getattr(sys, '__egginsert', 0)
        sys.path[p:p] = new
        sys.__egginsert = p + len(new)
        """
    )


if os.environ.get('SETUPTOOLS_SYS_PATH_TECHNIQUE', 'raw') == 'rewrite':
    PthDistributions = RewritePthDistributions


def _first_line_re():
    """
    Return a regular expression based on first_line_re suitable for matching
    strings.
    """
    if isinstance(first_line_re.pattern, str):
        return first_line_re

    # first_line_re in Python >=3.1.4 and >=3.2.1 is a bytes pattern.
    return re.compile(first_line_re.pattern.decode())


def auto_chmod(func, arg, exc):
    if func in [os.unlink, os.remove] and os.name == 'nt':
        chmod(arg, stat.S_IWRITE)
        return func(arg)
    et, ev, _ = sys.exc_info()
    # TODO: This code doesn't make sense. What is it trying to do?
    raise (ev[0], ev[1] + (" %s %s" % (func, arg)))


def update_dist_caches(dist_path, fix_zipimporter_caches):
    """
    Fix any globally cached `dist_path` related data

    `dist_path` should be a path of a newly installed egg distribution (zipped
    or unzipped).

    sys.path_importer_cache contains finder objects that have been cached when
    importing data from the original distribution. Any such finders need to be
    cleared since the replacement distribution might be packaged differently,
    e.g. a zipped egg distribution might get replaced with an unzipped egg
    folder or vice versa. Having the old finders cached may then cause Python
    to attempt loading modules from the replacement distribution using an
    incorrect loader.

    zipimport.zipimporter objects are Python loaders charged with importing
    data packaged inside zip archives. If stale loaders referencing the
    original distribution, are left behind, they can fail to load modules from
    the replacement distribution. E.g. if an old zipimport.zipimporter instance
    is used to load data from a new zipped egg archive, it may cause the
    operation to attempt to locate the requested data in the wrong location -
    one indicated by the original distribution's zip archive directory
    information. Such an operation may then fail outright, e.g. report having
    read a 'bad local file header', or even worse, it may fail silently &
    return invalid data.

    zipimport._zip_directory_cache contains cached zip archive directory
    information for all existing zipimport.zipimporter instances and all such
    instances connected to the same archive share the same cached directory
    information.

    If asked, and the underlying Python implementation allows it, we can fix
    all existing zipimport.zipimporter instances instead of having to track
    them down and remove them one by one, by updating their shared cached zip
    archive directory information. This, of course, assumes that the
    replacement distribution is packaged as a zipped egg.

    If not asked to fix existing zipimport.zipimporter instances, we still do
    our best to clear any remaining zipimport.zipimporter related cached data
    that might somehow later get used when attempting to load data from the new
    distribution and thus cause such load operations to fail. Note that when
    tracking down such remaining stale data, we can not catch every conceivable
    usage from here, and we clear only those that we know of and have found to
    cause problems if left alive. Any remaining caches should be updated by
    whomever is in charge of maintaining them, i.e. they should be ready to
    handle us replacing their zip archives with new distributions at runtime.

    """
    # There are several other known sources of stale zipimport.zipimporter
    # instances that we do not clear here, but might if ever given a reason to
    # do so:
    # * Global setuptools pkg_resources.working_set (a.k.a. 'master working
    # set') may contain distributions which may in turn contain their
    #   zipimport.zipimporter loaders.
    # * Several zipimport.zipimporter loaders held by local variables further
    #   up the function call stack when running the setuptools installation.
    # * Already loaded modules may have their __loader__ attribute set to the
    #   exact loader instance used when importing them. Python 3.4 docs state
    #   that this information is intended mostly for introspection and so is
    #   not expected to cause us problems.
    normalized_path = normalize_path(dist_path)
    _uncache(normalized_path, sys.path_importer_cache)
    if fix_zipimporter_caches:
        _replace_zip_directory_cache_data(normalized_path)
    else:
        # Here, even though we do not want to fix existing and now stale
        # zipimporter cache information, we still want to remove it. Related to
        # Python's zip archive directory information cache, we clear each of
        # its stale entries in two phases:
        #   1. Clear the entry so attempting to access zip archive information
        #      via any existing stale zipimport.zipimporter instances fails.
        #   2. Remove the entry from the cache so any newly constructed
        #      zipimport.zipimporter instances do not end up using old stale
        #      zip archive directory information.
        # This whole stale data removal step does not seem strictly necessary,
        # but has been left in because it was done before we started replacing
        # the zip archive directory information cache content if possible, and
        # there are no relevant unit tests that we can depend on to tell us if
        # this is really needed.
        _remove_and_clear_zip_directory_cache_data(normalized_path)


def _collect_zipimporter_cache_entries(normalized_path, cache):
    """
    Return zipimporter cache entry keys related to a given normalized path.

    Alternative path spellings (e.g. those using different character case or
    those using alternative path separators) related to the same path are
    included. Any sub-path entries are included as well, i.e. those
    corresponding to zip archives embedded in other zip archives.

    """
    result = []
    prefix_len = len(normalized_path)
    for p in cache:
        np = normalize_path(p)
        if np.startswith(normalized_path) and np[prefix_len : prefix_len + 1] in (
            os.sep,
            '',
        ):
            result.append(p)
    return result


def _update_zipimporter_cache(normalized_path, cache, updater=None):
    """
    Update zipimporter cache data for a given normalized path.

    Any sub-path entries are processed as well, i.e. those corresponding to zip
    archives embedded in other zip archives.

    Given updater is a callable taking a cache entry key and the original entry
    (after already removing the entry from the cache), and expected to update
    the entry and possibly return a new one to be inserted in its place.
    Returning None indicates that the entry should not be replaced with a new
    one. If no updater is given, the cache entries are simply removed without
    any additional processing, the same as if the updater simply returned None.

    """
    for p in _collect_zipimporter_cache_entries(normalized_path, cache):
        # N.B. pypy's custom zipimport._zip_directory_cache implementation does
        # not support the complete dict interface:
        # * Does not support item assignment, thus not allowing this function
        #    to be used only for removing existing cache entries.
        #  * Does not support the dict.pop() method, forcing us to use the
        #    get/del patterns instead. For more detailed information see the
        #    following links:
        #      https://github.com/pypa/setuptools/issues/202#issuecomment-202913420
        #      https://foss.heptapod.net/pypy/pypy/-/blob/144c4e65cb6accb8e592f3a7584ea38265d1873c/pypy/module/zipimport/interp_zipimport.py
        old_entry = cache[p]
        del cache[p]
        new_entry = updater and updater(p, old_entry)
        if new_entry is not None:
            cache[p] = new_entry


def _uncache(normalized_path, cache):
    _update_zipimporter_cache(normalized_path, cache)


def _remove_and_clear_zip_directory_cache_data(normalized_path):
    def clear_and_remove_cached_zip_archive_directory_data(path, old_entry):
        old_entry.clear()

    _update_zipimporter_cache(
        normalized_path,
        zipimport._zip_directory_cache,
        updater=clear_and_remove_cached_zip_archive_directory_data,
    )


# PyPy Python implementation does not allow directly writing to the
# zipimport._zip_directory_cache and so prevents us from attempting to correct
# its content. The best we can do there is clear the problematic cache content
# and have PyPy repopulate it as needed. The downside is that if there are any
# stale zipimport.zipimporter instances laying around, attempting to use them
# will fail due to not having its zip archive directory information available
# instead of being automatically corrected to use the new correct zip archive
# directory information.
if '__pypy__' in sys.builtin_module_names:
    _replace_zip_directory_cache_data = _remove_and_clear_zip_directory_cache_data
else:

    def _replace_zip_directory_cache_data(normalized_path):
        def replace_cached_zip_archive_directory_data(path, old_entry):
            # N.B. In theory, we could load the zip directory information just
            # once for all updated path spellings, and then copy it locally and
            # update its contained path strings to contain the correct
            # spelling, but that seems like a way too invasive move (this cache
            # structure is not officially documented anywhere and could in
            # theory change with new Python releases) for no significant
            # benefit.
            old_entry.clear()
            zipimport.zipimporter(path)
            old_entry.update(zipimport._zip_directory_cache[path])
            return old_entry

        _update_zipimporter_cache(
            normalized_path,
            zipimport._zip_directory_cache,
            updater=replace_cached_zip_archive_directory_data,
        )


def is_python(text, filename=''):
    "Is this string a valid Python script?"
    try:
        compile(text, filename, 'exec')
    except (SyntaxError, TypeError):
        return False
    else:
        return True


def is_sh(executable):
    """Determine if the specified executable is a .sh (contains a #! line)"""
    try:
        with io.open(executable, encoding='latin-1') as fp:
            magic = fp.read(2)
    except (OSError, IOError):
        return executable
    return magic == '#!'


def nt_quote_arg(arg):
    """Quote a command line argument according to Windows parsing rules"""
    return subprocess.list2cmdline([arg])


def is_python_script(script_text, filename):
    """Is this text, as a whole, a Python script? (as opposed to shell/bat/etc."""
    if filename.endswith('.py') or filename.endswith('.pyw'):
        return True  # extension says it's Python
    if is_python(script_text, filename):
        return True  # it's syntactically valid Python
    if script_text.startswith('#!'):
        # It begins with a '#!' line, so check if 'python' is in it somewhere
        return 'python' in script_text.splitlines()[0].lower()

    return False  # Not any Python I can recognize


try:
    from os import chmod as _chmod
except ImportError:
    # Jython compatibility
    def _chmod(*args):
        pass


def chmod(path, mode):
    log.debug("changing mode of %s to %o", path, mode)
    try:
        _chmod(path, mode)
    except os.error as e:
        log.debug("chmod failed: %s", e)


class CommandSpec(list):
    """
    A command spec for a #! header, specified as a list of arguments akin to
    those passed to Popen.
    """

    options = []
    split_args = dict()

    @classmethod
    def best(cls):
        """
        Choose the best CommandSpec class based on environmental conditions.
        """
        return cls

    @classmethod
    def _sys_executable(cls):
        _default = os.path.normpath(sys.executable)
        return os.environ.get('__PYVENV_LAUNCHER__', _default)

    @classmethod
    def from_param(cls, param):
        """
        Construct a CommandSpec from a parameter to build_scripts, which may
        be None.
        """
        if isinstance(param, cls):
            return param
        if isinstance(param, list):
            return cls(param)
        if param is None:
            return cls.from_environment()
        # otherwise, assume it's a string.
        return cls.from_string(param)

    @classmethod
    def from_environment(cls):
        return cls([cls._sys_executable()])

    @classmethod
    def from_string(cls, string):
        """
        Construct a command spec from a simple string representing a command
        line parseable by shlex.split.
        """
        items = shlex.split(string, **cls.split_args)
        return cls(items)

    def install_options(self, script_text):
        self.options = shlex.split(self._extract_options(script_text))
        cmdline = subprocess.list2cmdline(self)
        if not isascii(cmdline):
            self.options[:0] = ['-x']

    @staticmethod
    def _extract_options(orig_script):
        """
        Extract any options from the first line of the script.
        """
        first = (orig_script + '\n').splitlines()[0]
        match = _first_line_re().match(first)
        options = match.group(1) or '' if match else ''
        return options.strip()

    def as_header(self):
        return self._render(self + list(self.options))

    @staticmethod
    def _strip_quotes(item):
        _QUOTES = '"\''
        for q in _QUOTES:
            if item.startswith(q) and item.endswith(q):
                return item[1:-1]
        return item

    @staticmethod
    def _render(items):
        cmdline = subprocess.list2cmdline(
            CommandSpec._strip_quotes(item.strip()) for item in items
        )
        return '#!' + cmdline + '\n'


# For pbr compat; will be removed in a future version.
sys_executable = CommandSpec._sys_executable()


class WindowsCommandSpec(CommandSpec):
    split_args = dict(posix=False)


class ScriptWriter:
    """
    Encapsulates behavior around writing entry point scripts for console and
    gui apps.
    """

    template = textwrap.dedent(
        r"""
        # EASY-INSTALL-ENTRY-SCRIPT: %(spec)r,%(group)r,%(name)r
        import re
        import sys

        # for compatibility with easy_install; see #2198
        __requires__ = %(spec)r

        try:
            from importlib.metadata import distribution
        except ImportError:
            try:
                from importlib_metadata import distribution
            except ImportError:
                from pkg_resources import load_entry_point


        def importlib_load_entry_point(spec, group, name):
            dist_name, _, _ = spec.partition('==')
            matches = (
                entry_point
                for entry_point in distribution(dist_name).entry_points
                if entry_point.group == group and entry_point.name == name
            )
            return next(matches).load()


        globals().setdefault('load_entry_point', importlib_load_entry_point)


        if __name__ == '__main__':
            sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0])
            sys.exit(load_entry_point(%(spec)r, %(group)r, %(name)r)())
        """
    ).lstrip()

    command_spec_class = CommandSpec

    @classmethod
    def get_args(cls, dist, header=None):
        """
        Yield write_script() argument tuples for a distribution's
        console_scripts and gui_scripts entry points.
        """
        if header is None:
            header = cls.get_header()
        spec = str(dist.as_requirement())
        for type_ in 'console', 'gui':
            group = type_ + '_scripts'
            for name, ep in dist.get_entry_map(group).items():
                cls._ensure_safe_name(name)
                script_text = cls.template % locals()
                args = cls._get_script_args(type_, name, header, script_text)
                for res in args:
                    yield res

    @staticmethod
    def _ensure_safe_name(name):
        """
        Prevent paths in *_scripts entry point names.
        """
        has_path_sep = re.search(r'[\\/]', name)
        if has_path_sep:
            raise ValueError("Path separators not allowed in script names")

    @classmethod
    def best(cls):
        """
        Select the best ScriptWriter for this environment.
        """
        if sys.platform == 'win32' or (os.name == 'java' and os._name == 'nt'):
            return WindowsScriptWriter.best()
        else:
            return cls

    @classmethod
    def _get_script_args(cls, type_, name, header, script_text):
        # Simply write the stub with no extension.
        yield (name, header + script_text)

    @classmethod
    def get_header(cls, script_text="", executable=None):
        """Create a #! line, getting options (if any) from script_text"""
        cmd = cls.command_spec_class.best().from_param(executable)
        cmd.install_options(script_text)
        return cmd.as_header()


class WindowsScriptWriter(ScriptWriter):
    command_spec_class = WindowsCommandSpec

    @classmethod
    def best(cls):
        """
        Select the best ScriptWriter suitable for Windows
        """
        writer_lookup = dict(
            executable=WindowsExecutableLauncherWriter,
            natural=cls,
        )
        # for compatibility, use the executable launcher by default
        launcher = os.environ.get('SETUPTOOLS_LAUNCHER', 'executable')
        return writer_lookup[launcher]

    @classmethod
    def _get_script_args(cls, type_, name, header, script_text):
        "For Windows, add a .py extension"
        ext = dict(console='.pya', gui='.pyw')[type_]
        if ext not in os.environ['PATHEXT'].lower().split(';'):
            msg = (
                "{ext} not listed in PATHEXT; scripts will not be "
                "recognized as executables."
            ).format(**locals())
            SetuptoolsWarning.emit(msg)
        old = ['.pya', '.py', '-script.py', '.pyc', '.pyo', '.pyw', '.exe']
        old.remove(ext)
        header = cls._adjust_header(type_, header)
        blockers = [name + x for x in old]
        yield name + ext, header + script_text, 't', blockers

    @classmethod
    def _adjust_header(cls, type_, orig_header):
        """
        Make sure 'pythonw' is used for gui and 'python' is used for
        console (regardless of what sys.executable is).
        """
        pattern = 'pythonw.exe'
        repl = 'python.exe'
        if type_ == 'gui':
            pattern, repl = repl, pattern
        pattern_ob = re.compile(re.escape(pattern), re.IGNORECASE)
        new_header = pattern_ob.sub(string=orig_header, repl=repl)
        return new_header if cls._use_header(new_header) else orig_header

    @staticmethod
    def _use_header(new_header):
        """
        Should _adjust_header use the replaced header?

        On non-windows systems, always use. On
        Windows systems, only use the replaced header if it resolves
        to an executable on the system.
        """
        clean_header = new_header[2:-1].strip('"')
        return sys.platform != 'win32' or find_executable(clean_header)


class WindowsExecutableLauncherWriter(WindowsScriptWriter):
    @classmethod
    def _get_script_args(cls, type_, name, header, script_text):
        """
        For Windows, add a .py extension and an .exe launcher
        """
        if type_ == 'gui':
            launcher_type = 'gui'
            ext = '-script.pyw'
            old = ['.pyw']
        else:
            launcher_type = 'cli'
            ext = '-script.py'
            old = ['.py', '.pyc', '.pyo']
        hdr = cls._adjust_header(type_, header)
        blockers = [name + x for x in old]
        yield (name + ext, hdr + script_text, 't', blockers)
        yield (
            name + '.exe',
            get_win_launcher(launcher_type),
            'b',  # write in binary mode
        )
        if not is_64bit():
            # install a manifest for the launcher to prevent Windows
            # from detecting it as an installer (which it will for
            #  launchers like easy_install.exe). Consider only
            #  adding a manifest for launchers detected as installers.
            #  See Distribute #143 for details.
            m_name = name + '.exe.manifest'
            yield (m_name, load_launcher_manifest(name), 't')


def get_win_launcher(type):
    """
    Load the Windows launcher (executable) suitable for launching a script.

    `type` should be either 'cli' or 'gui'

    Returns the executable as a byte string.
    """
    launcher_fn = '%s.exe' % type
    if is_64bit():
        if get_platform() == "win-arm64":
            launcher_fn = launcher_fn.replace(".", "-arm64.")
        else:
            launcher_fn = launcher_fn.replace(".", "-64.")
    else:
        launcher_fn = launcher_fn.replace(".", "-32.")
    return resource_string('setuptools', launcher_fn)


def load_launcher_manifest(name):
    manifest = pkg_resources.resource_string(__name__, 'launcher manifest.xml')
    return manifest.decode('utf-8') % vars()


def _rmtree(path, ignore_errors=False, onexc=auto_chmod):
    return py312compat.shutil_rmtree(path, ignore_errors, onexc)


def current_umask():
    tmp = os.umask(0o022)
    os.umask(tmp)
    return tmp


def only_strs(values):
    """
    Exclude non-str values. Ref #3063.
    """
    return filter(lambda val: isinstance(val, str), values)


class EasyInstallDeprecationWarning(SetuptoolsDeprecationWarning):
    _SUMMARY = "easy_install command is deprecated."
    _DETAILS = """
    Please avoid running ``setup.py`` and ``easy_install``.
    Instead, use pypa/build, pypa/installer or other
    standards-based tools.
    """
    _SEE_URL = "https://github.com/pypa/setuptools/issues/917"
    # _DUE_DATE not defined yet
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/editable_wheel.py0000644000175100001730000010072614467657412022626 0ustar00runnerdocker"""
Create a wheel that, when installed, will make the source package 'editable'
(add it to the interpreter's path, including metadata) per PEP 660. Replaces
'setup.py develop'.

.. note::
   One of the mechanisms briefly mentioned in PEP 660 to implement editable installs is
   to create a separated directory inside ``build`` and use a .pth file to point to that
   directory. In the context of this file such directory is referred as
   *auxiliary build directory* or ``auxiliary_dir``.
"""

import logging
import io
import os
import shutil
import sys
import traceback
from contextlib import suppress
from enum import Enum
from inspect import cleandoc
from itertools import chain
from pathlib import Path
from tempfile import TemporaryDirectory
from typing import (
    TYPE_CHECKING,
    Dict,
    Iterable,
    Iterator,
    List,
    Mapping,
    Optional,
    Tuple,
    TypeVar,
    Union,
)

from .. import (
    Command,
    _normalization,
    _path,
    errors,
    namespaces,
)
from ..discovery import find_package_path
from ..dist import Distribution
from ..warnings import (
    InformationOnly,
    SetuptoolsDeprecationWarning,
    SetuptoolsWarning,
)
from .build_py import build_py as build_py_cls

if TYPE_CHECKING:
    from wheel.wheelfile import WheelFile  # noqa

if sys.version_info >= (3, 8):
    from typing import Protocol
elif TYPE_CHECKING:
    from typing_extensions import Protocol
else:
    from abc import ABC as Protocol

_Path = Union[str, Path]
_P = TypeVar("_P", bound=_Path)
_logger = logging.getLogger(__name__)


class _EditableMode(Enum):
    """
    Possible editable installation modes:
    `lenient` (new files automatically added to the package - DEFAULT);
    `strict` (requires a new installation when files are added/removed); or
    `compat` (attempts to emulate `python setup.py develop` - DEPRECATED).
    """

    STRICT = "strict"
    LENIENT = "lenient"
    COMPAT = "compat"  # TODO: Remove `compat` after Dec/2022.

    @classmethod
    def convert(cls, mode: Optional[str]) -> "_EditableMode":
        if not mode:
            return _EditableMode.LENIENT  # default

        _mode = mode.upper()
        if _mode not in _EditableMode.__members__:
            raise errors.OptionError(f"Invalid editable mode: {mode!r}. Try: 'strict'.")

        if _mode == "COMPAT":
            SetuptoolsDeprecationWarning.emit(
                "Compat editable installs",
                """
                The 'compat' editable mode is transitional and will be removed
                in future versions of `setuptools`.
                Please adapt your code accordingly to use either the 'strict' or the
                'lenient' modes.
                """,
                see_docs="userguide/development_mode.html",
                # TODO: define due_date
                # There is a series of shortcomings with the available editable install
                # methods, and they are very controversial. This is something that still
                # needs work.
                # Moreover, `pip` is still hiding this warning, so users are not aware.
            )

        return _EditableMode[_mode]


_STRICT_WARNING = """
New or renamed files may not be automatically picked up without a new installation.
"""

_LENIENT_WARNING = """
Options like `package-data`, `include/exclude-package-data` or
`packages.find.exclude/include` may have no effect.
"""


class editable_wheel(Command):
    """Build 'editable' wheel for development.
    This command is private and reserved for internal use of setuptools,
    users should rely on ``setuptools.build_meta`` APIs.
    """

    description = "DO NOT CALL DIRECTLY, INTERNAL ONLY: create PEP 660 editable wheel"

    user_options = [
        ("dist-dir=", "d", "directory to put final built distributions in"),
        ("dist-info-dir=", "I", "path to a pre-build .dist-info directory"),
        ("mode=", None, cleandoc(_EditableMode.__doc__ or "")),
    ]

    def initialize_options(self):
        self.dist_dir = None
        self.dist_info_dir = None
        self.project_dir = None
        self.mode = None

    def finalize_options(self):
        dist = self.distribution
        self.project_dir = dist.src_root or os.curdir
        self.package_dir = dist.package_dir or {}
        self.dist_dir = Path(self.dist_dir or os.path.join(self.project_dir, "dist"))

    def run(self):
        try:
            self.dist_dir.mkdir(exist_ok=True)
            self._ensure_dist_info()

            # Add missing dist_info files
            self.reinitialize_command("bdist_wheel")
            bdist_wheel = self.get_finalized_command("bdist_wheel")
            bdist_wheel.write_wheelfile(self.dist_info_dir)

            self._create_wheel_file(bdist_wheel)
        except Exception:
            traceback.print_exc()
            project = self.distribution.name or self.distribution.get_name()
            _DebuggingTips.emit(project=project)
            raise

    def _ensure_dist_info(self):
        if self.dist_info_dir is None:
            dist_info = self.reinitialize_command("dist_info")
            dist_info.output_dir = self.dist_dir
            dist_info.ensure_finalized()
            dist_info.run()
            self.dist_info_dir = dist_info.dist_info_dir
        else:
            assert str(self.dist_info_dir).endswith(".dist-info")
            assert Path(self.dist_info_dir, "METADATA").exists()

    def _install_namespaces(self, installation_dir, pth_prefix):
        # XXX: Only required to support the deprecated namespace practice
        dist = self.distribution
        if not dist.namespace_packages:
            return

        src_root = Path(self.project_dir, self.package_dir.get("", ".")).resolve()
        installer = _NamespaceInstaller(dist, installation_dir, pth_prefix, src_root)
        installer.install_namespaces()

    def _find_egg_info_dir(self) -> Optional[str]:
        parent_dir = Path(self.dist_info_dir).parent if self.dist_info_dir else Path()
        candidates = map(str, parent_dir.glob("*.egg-info"))
        return next(candidates, None)

    def _configure_build(
        self, name: str, unpacked_wheel: _Path, build_lib: _Path, tmp_dir: _Path
    ):
        """Configure commands to behave in the following ways:

        - Build commands can write to ``build_lib`` if they really want to...
          (but this folder is expected to be ignored and modules are expected to live
          in the project directory...)
        - Binary extensions should be built in-place (editable_mode = True)
        - Data/header/script files are not part of the "editable" specification
          so they are written directly to the unpacked_wheel directory.
        """
        # Non-editable files (data, headers, scripts) are written directly to the
        # unpacked_wheel

        dist = self.distribution
        wheel = str(unpacked_wheel)
        build_lib = str(build_lib)
        data = str(Path(unpacked_wheel, f"{name}.data", "data"))
        headers = str(Path(unpacked_wheel, f"{name}.data", "headers"))
        scripts = str(Path(unpacked_wheel, f"{name}.data", "scripts"))

        # egg-info may be generated again to create a manifest (used for package data)
        egg_info = dist.reinitialize_command("egg_info", reinit_subcommands=True)
        egg_info.egg_base = str(tmp_dir)
        egg_info.ignore_egg_info_in_manifest = True

        build = dist.reinitialize_command("build", reinit_subcommands=True)
        install = dist.reinitialize_command("install", reinit_subcommands=True)

        build.build_platlib = build.build_purelib = build.build_lib = build_lib
        install.install_purelib = install.install_platlib = install.install_lib = wheel
        install.install_scripts = build.build_scripts = scripts
        install.install_headers = headers
        install.install_data = data

        install_scripts = dist.get_command_obj("install_scripts")
        install_scripts.no_ep = True

        build.build_temp = str(tmp_dir)

        build_py = dist.get_command_obj("build_py")
        build_py.compile = False
        build_py.existing_egg_info_dir = self._find_egg_info_dir()

        self._set_editable_mode()

        build.ensure_finalized()
        install.ensure_finalized()

    def _set_editable_mode(self):
        """Set the ``editable_mode`` flag in the build sub-commands"""
        dist = self.distribution
        build = dist.get_command_obj("build")
        for cmd_name in build.get_sub_commands():
            cmd = dist.get_command_obj(cmd_name)
            if hasattr(cmd, "editable_mode"):
                cmd.editable_mode = True
            elif hasattr(cmd, "inplace"):
                cmd.inplace = True  # backward compatibility with distutils

    def _collect_build_outputs(self) -> Tuple[List[str], Dict[str, str]]:
        files: List[str] = []
        mapping: Dict[str, str] = {}
        build = self.get_finalized_command("build")

        for cmd_name in build.get_sub_commands():
            cmd = self.get_finalized_command(cmd_name)
            if hasattr(cmd, "get_outputs"):
                files.extend(cmd.get_outputs() or [])
            if hasattr(cmd, "get_output_mapping"):
                mapping.update(cmd.get_output_mapping() or {})

        return files, mapping

    def _run_build_commands(
        self, dist_name: str, unpacked_wheel: _Path, build_lib: _Path, tmp_dir: _Path
    ) -> Tuple[List[str], Dict[str, str]]:
        self._configure_build(dist_name, unpacked_wheel, build_lib, tmp_dir)
        self._run_build_subcommands()
        files, mapping = self._collect_build_outputs()
        self._run_install("headers")
        self._run_install("scripts")
        self._run_install("data")
        return files, mapping

    def _run_build_subcommands(self):
        """
        Issue #3501 indicates that some plugins/customizations might rely on:

        1. ``build_py`` not running
        2. ``build_py`` always copying files to ``build_lib``

        However both these assumptions may be false in editable_wheel.
        This method implements a temporary workaround to support the ecosystem
        while the implementations catch up.
        """
        # TODO: Once plugins/customisations had the chance to catch up, replace
        #       `self._run_build_subcommands()` with `self.run_command("build")`.
        #       Also remove _safely_run, TestCustomBuildPy. Suggested date: Aug/2023.
        build: Command = self.get_finalized_command("build")
        for name in build.get_sub_commands():
            cmd = self.get_finalized_command(name)
            if name == "build_py" and type(cmd) != build_py_cls:
                self._safely_run(name)
            else:
                self.run_command(name)

    def _safely_run(self, cmd_name: str):
        try:
            return self.run_command(cmd_name)
        except Exception:
            SetuptoolsDeprecationWarning.emit(
                "Customization incompatible with editable install",
                f"""
                {traceback.format_exc()}

                If you are seeing this warning it is very likely that a setuptools
                plugin or customization overrides the `{cmd_name}` command, without
                taking into consideration how editable installs run build steps
                starting from setuptools v64.0.0.

                Plugin authors and developers relying on custom build steps are
                encouraged to update their `{cmd_name}` implementation considering the
                information about editable installs in
                https://setuptools.pypa.io/en/latest/userguide/extension.html.

                For the time being `setuptools` will silence this error and ignore
                the faulty command, but this behaviour will change in future versions.
                """,
                # TODO: define due_date
                # There is a series of shortcomings with the available editable install
                # methods, and they are very controversial. This is something that still
                # needs work.
            )

    def _create_wheel_file(self, bdist_wheel):
        from wheel.wheelfile import WheelFile

        dist_info = self.get_finalized_command("dist_info")
        dist_name = dist_info.name
        tag = "-".join(bdist_wheel.get_tag())
        build_tag = "0.editable"  # According to PEP 427 needs to start with digit
        archive_name = f"{dist_name}-{build_tag}-{tag}.whl"
        wheel_path = Path(self.dist_dir, archive_name)
        if wheel_path.exists():
            wheel_path.unlink()

        unpacked_wheel = TemporaryDirectory(suffix=archive_name)
        build_lib = TemporaryDirectory(suffix=".build-lib")
        build_tmp = TemporaryDirectory(suffix=".build-temp")

        with unpacked_wheel as unpacked, build_lib as lib, build_tmp as tmp:
            unpacked_dist_info = Path(unpacked, Path(self.dist_info_dir).name)
            shutil.copytree(self.dist_info_dir, unpacked_dist_info)
            self._install_namespaces(unpacked, dist_info.name)
            files, mapping = self._run_build_commands(dist_name, unpacked, lib, tmp)
            strategy = self._select_strategy(dist_name, tag, lib)
            with strategy, WheelFile(wheel_path, "w") as wheel_obj:
                strategy(wheel_obj, files, mapping)
                wheel_obj.write_files(unpacked)

        return wheel_path

    def _run_install(self, category: str):
        has_category = getattr(self.distribution, f"has_{category}", None)
        if has_category and has_category():
            _logger.info(f"Installing {category} as non editable")
            self.run_command(f"install_{category}")

    def _select_strategy(
        self,
        name: str,
        tag: str,
        build_lib: _Path,
    ) -> "EditableStrategy":
        """Decides which strategy to use to implement an editable installation."""
        build_name = f"__editable__.{name}-{tag}"
        project_dir = Path(self.project_dir)
        mode = _EditableMode.convert(self.mode)

        if mode is _EditableMode.STRICT:
            auxiliary_dir = _empty_dir(Path(self.project_dir, "build", build_name))
            return _LinkTree(self.distribution, name, auxiliary_dir, build_lib)

        packages = _find_packages(self.distribution)
        has_simple_layout = _simple_layout(packages, self.package_dir, project_dir)
        is_compat_mode = mode is _EditableMode.COMPAT
        if set(self.package_dir) == {""} and has_simple_layout or is_compat_mode:
            # src-layout(ish) is relatively safe for a simple pth file
            src_dir = self.package_dir.get("", ".")
            return _StaticPth(self.distribution, name, [Path(project_dir, src_dir)])

        # Use a MetaPathFinder to avoid adding accidental top-level packages/modules
        return _TopLevelFinder(self.distribution, name)


class EditableStrategy(Protocol):
    def __call__(self, wheel: "WheelFile", files: List[str], mapping: Dict[str, str]):
        ...

    def __enter__(self):
        ...

    def __exit__(self, _exc_type, _exc_value, _traceback):
        ...


class _StaticPth:
    def __init__(self, dist: Distribution, name: str, path_entries: List[Path]):
        self.dist = dist
        self.name = name
        self.path_entries = path_entries

    def __call__(self, wheel: "WheelFile", files: List[str], mapping: Dict[str, str]):
        entries = "\n".join((str(p.resolve()) for p in self.path_entries))
        contents = _encode_pth(f"{entries}\n")
        wheel.writestr(f"__editable__.{self.name}.pth", contents)

    def __enter__(self):
        msg = f"""
        Editable install will be performed using .pth file to extend `sys.path` with:
        {list(map(os.fspath, self.path_entries))!r}
        """
        _logger.warning(msg + _LENIENT_WARNING)
        return self

    def __exit__(self, _exc_type, _exc_value, _traceback):
        ...


class _LinkTree(_StaticPth):
    """
    Creates a ``.pth`` file that points to a link tree in the ``auxiliary_dir``.

    This strategy will only link files (not dirs), so it can be implemented in
    any OS, even if that means using hardlinks instead of symlinks.

    By collocating ``auxiliary_dir`` and the original source code, limitations
    with hardlinks should be avoided.
    """

    def __init__(
        self,
        dist: Distribution,
        name: str,
        auxiliary_dir: _Path,
        build_lib: _Path,
    ):
        self.auxiliary_dir = Path(auxiliary_dir)
        self.build_lib = Path(build_lib).resolve()
        self._file = dist.get_command_obj("build_py").copy_file
        super().__init__(dist, name, [self.auxiliary_dir])

    def __call__(self, wheel: "WheelFile", files: List[str], mapping: Dict[str, str]):
        self._create_links(files, mapping)
        super().__call__(wheel, files, mapping)

    def _normalize_output(self, file: str) -> Optional[str]:
        # Files relative to build_lib will be normalized to None
        with suppress(ValueError):
            path = Path(file).resolve().relative_to(self.build_lib)
            return str(path).replace(os.sep, '/')
        return None

    def _create_file(self, relative_output: str, src_file: str, link=None):
        dest = self.auxiliary_dir / relative_output
        if not dest.parent.is_dir():
            dest.parent.mkdir(parents=True)
        self._file(src_file, dest, link=link)

    def _create_links(self, outputs, output_mapping):
        self.auxiliary_dir.mkdir(parents=True, exist_ok=True)
        link_type = "sym" if _can_symlink_files(self.auxiliary_dir) else "hard"
        mappings = {self._normalize_output(k): v for k, v in output_mapping.items()}
        mappings.pop(None, None)  # remove files that are not relative to build_lib

        for output in outputs:
            relative = self._normalize_output(output)
            if relative and relative not in mappings:
                self._create_file(relative, output)

        for relative, src in mappings.items():
            self._create_file(relative, src, link=link_type)

    def __enter__(self):
        msg = "Strict editable install will be performed using a link tree.\n"
        _logger.warning(msg + _STRICT_WARNING)
        return self

    def __exit__(self, _exc_type, _exc_value, _traceback):
        msg = f"""\n
        Strict editable installation performed using the auxiliary directory:
            {self.auxiliary_dir}

        Please be careful to not remove this directory, otherwise you might not be able
        to import/use your package.
        """
        InformationOnly.emit("Editable installation.", msg)


class _TopLevelFinder:
    def __init__(self, dist: Distribution, name: str):
        self.dist = dist
        self.name = name

    def __call__(self, wheel: "WheelFile", files: List[str], mapping: Dict[str, str]):
        src_root = self.dist.src_root or os.curdir
        top_level = chain(_find_packages(self.dist), _find_top_level_modules(self.dist))
        package_dir = self.dist.package_dir or {}
        roots = _find_package_roots(top_level, package_dir, src_root)

        namespaces_: Dict[str, List[str]] = dict(
            chain(
                _find_namespaces(self.dist.packages or [], roots),
                ((ns, []) for ns in _find_virtual_namespaces(roots)),
            )
        )

        name = f"__editable__.{self.name}.finder"
        finder = _normalization.safe_identifier(name)
        content = bytes(_finder_template(name, roots, namespaces_), "utf-8")
        wheel.writestr(f"{finder}.py", content)

        content = _encode_pth(f"import {finder}; {finder}.install()")
        wheel.writestr(f"__editable__.{self.name}.pth", content)

    def __enter__(self):
        msg = "Editable install will be performed using a meta path finder.\n"
        _logger.warning(msg + _LENIENT_WARNING)
        return self

    def __exit__(self, _exc_type, _exc_value, _traceback):
        msg = """\n
        Please be careful with folders in your working directory with the same
        name as your package as they may take precedence during imports.
        """
        InformationOnly.emit("Editable installation.", msg)


def _encode_pth(content: str) -> bytes:
    """.pth files are always read with 'locale' encoding, the recommendation
    from the cpython core developers is to write them as ``open(path, "w")``
    and ignore warnings (see python/cpython#77102, pypa/setuptools#3937).
    This function tries to simulate this behaviour without having to create an
    actual file, in a way that supports a range of active Python versions.
    (There seems to be some variety in the way different version of Python handle
    ``encoding=None``, not all of them use ``locale.getpreferredencoding(False)``).
    """
    encoding = "locale" if sys.version_info >= (3, 10) else None
    with io.BytesIO() as buffer:
        wrapper = io.TextIOWrapper(buffer, encoding)
        wrapper.write(content)
        wrapper.flush()
        buffer.seek(0)
        return buffer.read()


def _can_symlink_files(base_dir: Path) -> bool:
    with TemporaryDirectory(dir=str(base_dir.resolve())) as tmp:
        path1, path2 = Path(tmp, "file1.txt"), Path(tmp, "file2.txt")
        path1.write_text("file1", encoding="utf-8")
        with suppress(AttributeError, NotImplementedError, OSError):
            os.symlink(path1, path2)
            if path2.is_symlink() and path2.read_text(encoding="utf-8") == "file1":
                return True

        try:
            os.link(path1, path2)  # Ensure hard links can be created
        except Exception as ex:
            msg = (
                "File system does not seem to support either symlinks or hard links. "
                "Strict editable installs require one of them to be supported."
            )
            raise LinksNotSupported(msg) from ex
        return False


def _simple_layout(
    packages: Iterable[str], package_dir: Dict[str, str], project_dir: Path
) -> bool:
    """Return ``True`` if:
    - all packages are contained by the same parent directory, **and**
    - all packages become importable if the parent directory is added to ``sys.path``.

    >>> _simple_layout(['a'], {"": "src"}, "/tmp/myproj")
    True
    >>> _simple_layout(['a', 'a.b'], {"": "src"}, "/tmp/myproj")
    True
    >>> _simple_layout(['a', 'a.b'], {}, "/tmp/myproj")
    True
    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"": "src"}, "/tmp/myproj")
    True
    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "a", "b": "b"}, ".")
    True
    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a", "b": "_b"}, ".")
    False
    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a": "_a"}, "/tmp/myproj")
    False
    >>> _simple_layout(['a', 'a.a1', 'a.a1.a2', 'b'], {"a.a1.a2": "_a2"}, ".")
    False
    >>> _simple_layout(['a', 'a.b'], {"": "src", "a.b": "_ab"}, "/tmp/myproj")
    False
    >>> # Special cases, no packages yet:
    >>> _simple_layout([], {"": "src"}, "/tmp/myproj")
    True
    >>> _simple_layout([], {"a": "_a", "": "src"}, "/tmp/myproj")
    False
    """
    layout = {pkg: find_package_path(pkg, package_dir, project_dir) for pkg in packages}
    if not layout:
        return set(package_dir) in ({}, {""})
    parent = os.path.commonpath([_parent_path(k, v) for k, v in layout.items()])
    return all(
        _path.same_path(Path(parent, *key.split('.')), value)
        for key, value in layout.items()
    )


def _parent_path(pkg, pkg_path):
    """Infer the parent path containing a package, that if added to ``sys.path`` would
    allow importing that package.
    When ``pkg`` is directly mapped into a directory with a different name, return its
    own path.
    >>> _parent_path("a", "src/a")
    'src'
    >>> _parent_path("b", "src/c")
    'src/c'
    """
    parent = pkg_path[: -len(pkg)] if pkg_path.endswith(pkg) else pkg_path
    return parent.rstrip("/" + os.sep)


def _find_packages(dist: Distribution) -> Iterator[str]:
    yield from iter(dist.packages or [])

    py_modules = dist.py_modules or []
    nested_modules = [mod for mod in py_modules if "." in mod]
    if dist.ext_package:
        yield dist.ext_package
    else:
        ext_modules = dist.ext_modules or []
        nested_modules += [x.name for x in ext_modules if "." in x.name]

    for module in nested_modules:
        package, _, _ = module.rpartition(".")
        yield package


def _find_top_level_modules(dist: Distribution) -> Iterator[str]:
    py_modules = dist.py_modules or []
    yield from (mod for mod in py_modules if "." not in mod)

    if not dist.ext_package:
        ext_modules = dist.ext_modules or []
        yield from (x.name for x in ext_modules if "." not in x.name)


def _find_package_roots(
    packages: Iterable[str],
    package_dir: Mapping[str, str],
    src_root: _Path,
) -> Dict[str, str]:
    pkg_roots: Dict[str, str] = {
        pkg: _absolute_root(find_package_path(pkg, package_dir, src_root))
        for pkg in sorted(packages)
    }

    return _remove_nested(pkg_roots)


def _absolute_root(path: _Path) -> str:
    """Works for packages and top-level modules"""
    path_ = Path(path)
    parent = path_.parent

    if path_.exists():
        return str(path_.resolve())
    else:
        return str(parent.resolve() / path_.name)


def _find_virtual_namespaces(pkg_roots: Dict[str, str]) -> Iterator[str]:
    """By carefully designing ``package_dir``, it is possible to implement the logical
    structure of PEP 420 in a package without the corresponding directories.

    Moreover a parent package can be purposefully/accidentally skipped in the discovery
    phase (e.g. ``find_packages(include=["mypkg.*"])``, when ``mypkg.foo`` is included
    by ``mypkg`` itself is not).
    We consider this case to also be a virtual namespace (ignoring the original
    directory) to emulate a non-editable installation.

    This function will try to find these kinds of namespaces.
    """
    for pkg in pkg_roots:
        if "." not in pkg:
            continue
        parts = pkg.split(".")
        for i in range(len(parts) - 1, 0, -1):
            partial_name = ".".join(parts[:i])
            path = Path(find_package_path(partial_name, pkg_roots, ""))
            if not path.exists() or partial_name not in pkg_roots:
                # partial_name not in pkg_roots ==> purposefully/accidentally skipped
                yield partial_name


def _find_namespaces(
    packages: List[str], pkg_roots: Dict[str, str]
) -> Iterator[Tuple[str, List[str]]]:
    for pkg in packages:
        path = find_package_path(pkg, pkg_roots, "")
        if Path(path).exists() and not Path(path, "__init__.py").exists():
            yield (pkg, [path])


def _remove_nested(pkg_roots: Dict[str, str]) -> Dict[str, str]:
    output = dict(pkg_roots.copy())

    for pkg, path in reversed(list(pkg_roots.items())):
        if any(
            pkg != other and _is_nested(pkg, path, other, other_path)
            for other, other_path in pkg_roots.items()
        ):
            output.pop(pkg)

    return output


def _is_nested(pkg: str, pkg_path: str, parent: str, parent_path: str) -> bool:
    """
    Return ``True`` if ``pkg`` is nested inside ``parent`` both logically and in the
    file system.
    >>> _is_nested("a.b", "path/a/b", "a", "path/a")
    True
    >>> _is_nested("a.b", "path/a/b", "a", "otherpath/a")
    False
    >>> _is_nested("a.b", "path/a/b", "c", "path/c")
    False
    >>> _is_nested("a.a", "path/a/a", "a", "path/a")
    True
    >>> _is_nested("b.a", "path/b/a", "a", "path/a")
    False
    """
    norm_pkg_path = _path.normpath(pkg_path)
    rest = pkg.replace(parent, "", 1).strip(".").split(".")
    return pkg.startswith(parent) and norm_pkg_path == _path.normpath(
        Path(parent_path, *rest)
    )


def _empty_dir(dir_: _P) -> _P:
    """Create a directory ensured to be empty. Existing files may be removed."""
    shutil.rmtree(dir_, ignore_errors=True)
    os.makedirs(dir_)
    return dir_


class _NamespaceInstaller(namespaces.Installer):
    def __init__(self, distribution, installation_dir, editable_name, src_root):
        self.distribution = distribution
        self.src_root = src_root
        self.installation_dir = installation_dir
        self.editable_name = editable_name
        self.outputs = []
        self.dry_run = False

    def _get_target(self):
        """Installation target."""
        return os.path.join(self.installation_dir, self.editable_name)

    def _get_root(self):
        """Where the modules/packages should be loaded from."""
        return repr(str(self.src_root))


_FINDER_TEMPLATE = """\
import sys
from importlib.machinery import ModuleSpec, PathFinder
from importlib.machinery import all_suffixes as module_suffixes
from importlib.util import spec_from_file_location
from itertools import chain
from pathlib import Path

MAPPING = {mapping!r}
NAMESPACES = {namespaces!r}
PATH_PLACEHOLDER = {name!r} + ".__path_hook__"


class _EditableFinder:  # MetaPathFinder
    @classmethod
    def find_spec(cls, fullname, path=None, target=None):
        # Top-level packages and modules (we know these exist in the FS)
        if fullname in MAPPING:
            pkg_path = MAPPING[fullname]
            return cls._find_spec(fullname, Path(pkg_path))

        # Handle immediate children modules (required for namespaces to work)
        # To avoid problems with case sensitivity in the file system we delegate
        # to the importlib.machinery implementation.
        parent, _, child = fullname.rpartition(".")
        if parent and parent in MAPPING:
            return PathFinder.find_spec(fullname, path=[MAPPING[parent]])

        # Other levels of nesting should be handled automatically by importlib
        # using the parent path.
        return None

    @classmethod
    def _find_spec(cls, fullname, candidate_path):
        init = candidate_path / "__init__.py"
        candidates = (candidate_path.with_suffix(x) for x in module_suffixes())
        for candidate in chain([init], candidates):
            if candidate.exists():
                return spec_from_file_location(fullname, candidate)


class _EditableNamespaceFinder:  # PathEntryFinder
    @classmethod
    def _path_hook(cls, path):
        if path == PATH_PLACEHOLDER:
            return cls
        raise ImportError

    @classmethod
    def _paths(cls, fullname):
        # Ensure __path__ is not empty for the spec to be considered a namespace.
        return NAMESPACES[fullname] or MAPPING.get(fullname) or [PATH_PLACEHOLDER]

    @classmethod
    def find_spec(cls, fullname, target=None):
        if fullname in NAMESPACES:
            spec = ModuleSpec(fullname, None, is_package=True)
            spec.submodule_search_locations = cls._paths(fullname)
            return spec
        return None

    @classmethod
    def find_module(cls, fullname):
        return None


def install():
    if not any(finder == _EditableFinder for finder in sys.meta_path):
        sys.meta_path.append(_EditableFinder)

    if not NAMESPACES:
        return

    if not any(hook == _EditableNamespaceFinder._path_hook for hook in sys.path_hooks):
        # PathEntryFinder is needed to create NamespaceSpec without private APIS
        sys.path_hooks.append(_EditableNamespaceFinder._path_hook)
    if PATH_PLACEHOLDER not in sys.path:
        sys.path.append(PATH_PLACEHOLDER)  # Used just to trigger the path hook
"""


def _finder_template(
    name: str, mapping: Mapping[str, str], namespaces: Dict[str, List[str]]
) -> str:
    """Create a string containing the code for the``MetaPathFinder`` and
    ``PathEntryFinder``.
    """
    mapping = dict(sorted(mapping.items(), key=lambda p: p[0]))
    return _FINDER_TEMPLATE.format(name=name, mapping=mapping, namespaces=namespaces)


class LinksNotSupported(errors.FileError):
    """File system does not seem to support either symlinks or hard links."""


class _DebuggingTips(SetuptoolsWarning):
    _SUMMARY = "Problem in editable installation."
    _DETAILS = """
    An error happened while installing `{project}` in editable mode.

    The following steps are recommended to help debug this problem:

    - Try to install the project normally, without using the editable mode.
      Does the error still persist?
      (If it does, try fixing the problem before attempting the editable mode).
    - If you are using binary extensions, make sure you have all OS-level
      dependencies installed (e.g. compilers, toolchains, binary libraries, ...).
    - Try the latest version of setuptools (maybe the error was already fixed).
    - If you (or your project dependencies) are using any setuptools extension
      or customization, make sure they support the editable mode.

    After following the steps above, if the problem still persists and
    you think this is related to how setuptools handles editable installations,
    please submit a reproducible example
    (see https://stackoverflow.com/help/minimal-reproducible-example) to:

        https://github.com/pypa/setuptools/issues
    """
    _SEE_DOCS = "userguide/development_mode.html"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/egg_info.py0000644000175100001730000006476614467657412021463 0ustar00runnerdocker"""setuptools.command.egg_info

Create a distribution's .egg-info directory and contents"""

from distutils.filelist import FileList as _FileList
from distutils.errors import DistutilsInternalError
from distutils.util import convert_path
from distutils import log
import distutils.errors
import distutils.filelist
import functools
import os
import re
import sys
import io
import time
import collections

from .._importlib import metadata
from .. import _entry_points, _normalization

from setuptools import Command
from setuptools.command.sdist import sdist
from setuptools.command.sdist import walk_revctrl
from setuptools.command.setopt import edit_config
from setuptools.command import bdist_egg
import setuptools.unicode_utils as unicode_utils
from setuptools.glob import glob

from setuptools.extern import packaging
from setuptools.extern.jaraco.text import yield_lines
from ..warnings import SetuptoolsDeprecationWarning


PY_MAJOR = '{}.{}'.format(*sys.version_info)


def translate_pattern(glob):  # noqa: C901  # is too complex (14)  # FIXME
    """
    Translate a file path glob like '*.txt' in to a regular expression.
    This differs from fnmatch.translate which allows wildcards to match
    directory separators. It also knows about '**/' which matches any number of
    directories.
    """
    pat = ''

    # This will split on '/' within [character classes]. This is deliberate.
    chunks = glob.split(os.path.sep)

    sep = re.escape(os.sep)
    valid_char = '[^%s]' % (sep,)

    for c, chunk in enumerate(chunks):
        last_chunk = c == len(chunks) - 1

        # Chunks that are a literal ** are globstars. They match anything.
        if chunk == '**':
            if last_chunk:
                # Match anything if this is the last component
                pat += '.*'
            else:
                # Match '(name/)*'
                pat += '(?:%s+%s)*' % (valid_char, sep)
            continue  # Break here as the whole path component has been handled

        # Find any special characters in the remainder
        i = 0
        chunk_len = len(chunk)
        while i < chunk_len:
            char = chunk[i]
            if char == '*':
                # Match any number of name characters
                pat += valid_char + '*'
            elif char == '?':
                # Match a name character
                pat += valid_char
            elif char == '[':
                # Character class
                inner_i = i + 1
                # Skip initial !/] chars
                if inner_i < chunk_len and chunk[inner_i] == '!':
                    inner_i = inner_i + 1
                if inner_i < chunk_len and chunk[inner_i] == ']':
                    inner_i = inner_i + 1

                # Loop till the closing ] is found
                while inner_i < chunk_len and chunk[inner_i] != ']':
                    inner_i = inner_i + 1

                if inner_i >= chunk_len:
                    # Got to the end of the string without finding a closing ]
                    # Do not treat this as a matching group, but as a literal [
                    pat += re.escape(char)
                else:
                    # Grab the insides of the [brackets]
                    inner = chunk[i + 1 : inner_i]
                    char_class = ''

                    # Class negation
                    if inner[0] == '!':
                        char_class = '^'
                        inner = inner[1:]

                    char_class += re.escape(inner)
                    pat += '[%s]' % (char_class,)

                    # Skip to the end ]
                    i = inner_i
            else:
                pat += re.escape(char)
            i += 1

        # Join each chunk with the dir separator
        if not last_chunk:
            pat += sep

    pat += r'\Z'
    return re.compile(pat, flags=re.MULTILINE | re.DOTALL)


class InfoCommon:
    tag_build = None
    tag_date = None

    @property
    def name(self):
        return _normalization.safe_name(self.distribution.get_name())

    def tagged_version(self):
        tagged = self._maybe_tag(self.distribution.get_version())
        return _normalization.best_effort_version(tagged)

    def _maybe_tag(self, version):
        """
        egg_info may be called more than once for a distribution,
        in which case the version string already contains all tags.
        """
        return (
            version
            if self.vtags and self._already_tagged(version)
            else version + self.vtags
        )

    def _already_tagged(self, version: str) -> bool:
        # Depending on their format, tags may change with version normalization.
        # So in addition the regular tags, we have to search for the normalized ones.
        return version.endswith(self.vtags) or version.endswith(self._safe_tags())

    def _safe_tags(self) -> str:
        # To implement this we can rely on `safe_version` pretending to be version 0
        # followed by tags. Then we simply discard the starting 0 (fake version number)
        return _normalization.best_effort_version(f"0{self.vtags}")[1:]

    def tags(self) -> str:
        version = ''
        if self.tag_build:
            version += self.tag_build
        if self.tag_date:
            version += time.strftime("%Y%m%d")
        return version

    vtags = property(tags)


class egg_info(InfoCommon, Command):
    description = "create a distribution's .egg-info directory"

    user_options = [
        (
            'egg-base=',
            'e',
            "directory containing .egg-info directories"
            " (default: top of the source tree)",
        ),
        ('tag-date', 'd', "Add date stamp (e.g. 20050528) to version number"),
        ('tag-build=', 'b', "Specify explicit tag to add to version number"),
        ('no-date', 'D', "Don't include date stamp [default]"),
    ]

    boolean_options = ['tag-date']
    negative_opt = {
        'no-date': 'tag-date',
    }

    def initialize_options(self):
        self.egg_base = None
        self.egg_name = None
        self.egg_info = None
        self.egg_version = None
        self.ignore_egg_info_in_manifest = False

    ####################################
    # allow the 'tag_svn_revision' to be detected and
    # set, supporting sdists built on older Setuptools.
    @property
    def tag_svn_revision(self):
        pass

    @tag_svn_revision.setter
    def tag_svn_revision(self, value):
        pass

    ####################################

    def save_version_info(self, filename):
        """
        Materialize the value of date into the
        build tag. Install build keys in a deterministic order
        to avoid arbitrary reordering on subsequent builds.
        """
        egg_info = collections.OrderedDict()
        # follow the order these keys would have been added
        # when PYTHONHASHSEED=0
        egg_info['tag_build'] = self.tags()
        egg_info['tag_date'] = 0
        edit_config(filename, dict(egg_info=egg_info))

    def finalize_options(self):
        # Note: we need to capture the current value returned
        # by `self.tagged_version()`, so we can later update
        # `self.distribution.metadata.version` without
        # repercussions.
        self.egg_name = self.name
        self.egg_version = self.tagged_version()
        parsed_version = packaging.version.Version(self.egg_version)

        try:
            is_version = isinstance(parsed_version, packaging.version.Version)
            spec = "%s==%s" if is_version else "%s===%s"
            packaging.requirements.Requirement(spec % (self.egg_name, self.egg_version))
        except ValueError as e:
            raise distutils.errors.DistutilsOptionError(
                "Invalid distribution name or version syntax: %s-%s"
                % (self.egg_name, self.egg_version)
            ) from e

        if self.egg_base is None:
            dirs = self.distribution.package_dir
            self.egg_base = (dirs or {}).get('', os.curdir)

        self.ensure_dirname('egg_base')
        self.egg_info = _normalization.filename_component(self.egg_name) + '.egg-info'
        if self.egg_base != os.curdir:
            self.egg_info = os.path.join(self.egg_base, self.egg_info)

        # Set package version for the benefit of dumber commands
        # (e.g. sdist, bdist_wininst, etc.)
        #
        self.distribution.metadata.version = self.egg_version

        # If we bootstrapped around the lack of a PKG-INFO, as might be the
        # case in a fresh checkout, make sure that any special tags get added
        # to the version info
        #
        pd = self.distribution._patched_dist
        key = getattr(pd, "key", None) or getattr(pd, "name", None)
        if pd is not None and key == self.egg_name.lower():
            pd._version = self.egg_version
            pd._parsed_version = packaging.version.Version(self.egg_version)
            self.distribution._patched_dist = None

    def _get_egg_basename(self, py_version=PY_MAJOR, platform=None):
        """Compute filename of the output egg. Private API."""
        return _egg_basename(self.egg_name, self.egg_version, py_version, platform)

    def write_or_delete_file(self, what, filename, data, force=False):
        """Write `data` to `filename` or delete if empty

        If `data` is non-empty, this routine is the same as ``write_file()``.
        If `data` is empty but not ``None``, this is the same as calling
        ``delete_file(filename)`.  If `data` is ``None``, then this is a no-op
        unless `filename` exists, in which case a warning is issued about the
        orphaned file (if `force` is false), or deleted (if `force` is true).
        """
        if data:
            self.write_file(what, filename, data)
        elif os.path.exists(filename):
            if data is None and not force:
                log.warn("%s not set in setup(), but %s exists", what, filename)
                return
            else:
                self.delete_file(filename)

    def write_file(self, what, filename, data):
        """Write `data` to `filename` (if not a dry run) after announcing it

        `what` is used in a log message to identify what is being written
        to the file.
        """
        log.info("writing %s to %s", what, filename)
        data = data.encode("utf-8")
        if not self.dry_run:
            f = open(filename, 'wb')
            f.write(data)
            f.close()

    def delete_file(self, filename):
        """Delete `filename` (if not a dry run) after announcing it"""
        log.info("deleting %s", filename)
        if not self.dry_run:
            os.unlink(filename)

    def run(self):
        self.mkpath(self.egg_info)
        try:
            os.utime(self.egg_info, None)
        except OSError as e:
            msg = f"Cannot update time stamp of directory '{self.egg_info}'"
            raise distutils.errors.DistutilsFileError(msg) from e
        for ep in metadata.entry_points(group='egg_info.writers'):
            writer = ep.load()
            writer(self, ep.name, os.path.join(self.egg_info, ep.name))

        # Get rid of native_libs.txt if it was put there by older bdist_egg
        nl = os.path.join(self.egg_info, "native_libs.txt")
        if os.path.exists(nl):
            self.delete_file(nl)

        self.find_sources()

    def find_sources(self):
        """Generate SOURCES.txt manifest file"""
        manifest_filename = os.path.join(self.egg_info, "SOURCES.txt")
        mm = manifest_maker(self.distribution)
        mm.ignore_egg_info_dir = self.ignore_egg_info_in_manifest
        mm.manifest = manifest_filename
        mm.run()
        self.filelist = mm.filelist


class FileList(_FileList):
    # Implementations of the various MANIFEST.in commands

    def __init__(self, warn=None, debug_print=None, ignore_egg_info_dir=False):
        super().__init__(warn, debug_print)
        self.ignore_egg_info_dir = ignore_egg_info_dir

    def process_template_line(self, line):
        # Parse the line: split it up, make sure the right number of words
        # is there, and return the relevant words.  'action' is always
        # defined: it's the first word of the line.  Which of the other
        # three are defined depends on the action; it'll be either
        # patterns, (dir and patterns), or (dir_pattern).
        (action, patterns, dir, dir_pattern) = self._parse_template_line(line)

        action_map = {
            'include': self.include,
            'exclude': self.exclude,
            'global-include': self.global_include,
            'global-exclude': self.global_exclude,
            'recursive-include': functools.partial(
                self.recursive_include,
                dir,
            ),
            'recursive-exclude': functools.partial(
                self.recursive_exclude,
                dir,
            ),
            'graft': self.graft,
            'prune': self.prune,
        }
        log_map = {
            'include': "warning: no files found matching '%s'",
            'exclude': ("warning: no previously-included files found " "matching '%s'"),
            'global-include': (
                "warning: no files found matching '%s' " "anywhere in distribution"
            ),
            'global-exclude': (
                "warning: no previously-included files matching "
                "'%s' found anywhere in distribution"
            ),
            'recursive-include': (
                "warning: no files found matching '%s' " "under directory '%s'"
            ),
            'recursive-exclude': (
                "warning: no previously-included files matching "
                "'%s' found under directory '%s'"
            ),
            'graft': "warning: no directories found matching '%s'",
            'prune': "no previously-included directories found matching '%s'",
        }

        try:
            process_action = action_map[action]
        except KeyError:
            raise DistutilsInternalError(
                "this cannot happen: invalid action '{action!s}'".format(action=action),
            )

        # OK, now we know that the action is valid and we have the
        # right number of words on the line for that action -- so we
        # can proceed with minimal error-checking.

        action_is_recursive = action.startswith('recursive-')
        if action in {'graft', 'prune'}:
            patterns = [dir_pattern]
        extra_log_args = (dir,) if action_is_recursive else ()
        log_tmpl = log_map[action]

        self.debug_print(
            ' '.join(
                [action] + ([dir] if action_is_recursive else []) + patterns,
            )
        )
        for pattern in patterns:
            if not process_action(pattern):
                log.warn(log_tmpl, pattern, *extra_log_args)

    def _remove_files(self, predicate):
        """
        Remove all files from the file list that match the predicate.
        Return True if any matching files were removed
        """
        found = False
        for i in range(len(self.files) - 1, -1, -1):
            if predicate(self.files[i]):
                self.debug_print(" removing " + self.files[i])
                del self.files[i]
                found = True
        return found

    def include(self, pattern):
        """Include files that match 'pattern'."""
        found = [f for f in glob(pattern) if not os.path.isdir(f)]
        self.extend(found)
        return bool(found)

    def exclude(self, pattern):
        """Exclude files that match 'pattern'."""
        match = translate_pattern(pattern)
        return self._remove_files(match.match)

    def recursive_include(self, dir, pattern):
        """
        Include all files anywhere in 'dir/' that match the pattern.
        """
        full_pattern = os.path.join(dir, '**', pattern)
        found = [f for f in glob(full_pattern, recursive=True) if not os.path.isdir(f)]
        self.extend(found)
        return bool(found)

    def recursive_exclude(self, dir, pattern):
        """
        Exclude any file anywhere in 'dir/' that match the pattern.
        """
        match = translate_pattern(os.path.join(dir, '**', pattern))
        return self._remove_files(match.match)

    def graft(self, dir):
        """Include all files from 'dir/'."""
        found = [
            item
            for match_dir in glob(dir)
            for item in distutils.filelist.findall(match_dir)
        ]
        self.extend(found)
        return bool(found)

    def prune(self, dir):
        """Filter out files from 'dir/'."""
        match = translate_pattern(os.path.join(dir, '**'))
        return self._remove_files(match.match)

    def global_include(self, pattern):
        """
        Include all files anywhere in the current directory that match the
        pattern. This is very inefficient on large file trees.
        """
        if self.allfiles is None:
            self.findall()
        match = translate_pattern(os.path.join('**', pattern))
        found = [f for f in self.allfiles if match.match(f)]
        self.extend(found)
        return bool(found)

    def global_exclude(self, pattern):
        """
        Exclude all files anywhere that match the pattern.
        """
        match = translate_pattern(os.path.join('**', pattern))
        return self._remove_files(match.match)

    def append(self, item):
        if item.endswith('\r'):  # Fix older sdists built on Windows
            item = item[:-1]
        path = convert_path(item)

        if self._safe_path(path):
            self.files.append(path)

    def extend(self, paths):
        self.files.extend(filter(self._safe_path, paths))

    def _repair(self):
        """
        Replace self.files with only safe paths

        Because some owners of FileList manipulate the underlying
        ``files`` attribute directly, this method must be called to
        repair those paths.
        """
        self.files = list(filter(self._safe_path, self.files))

    def _safe_path(self, path):
        enc_warn = "'%s' not %s encodable -- skipping"

        # To avoid accidental trans-codings errors, first to unicode
        u_path = unicode_utils.filesys_decode(path)
        if u_path is None:
            log.warn("'%s' in unexpected encoding -- skipping" % path)
            return False

        # Must ensure utf-8 encodability
        utf8_path = unicode_utils.try_encode(u_path, "utf-8")
        if utf8_path is None:
            log.warn(enc_warn, path, 'utf-8')
            return False

        try:
            # ignore egg-info paths
            is_egg_info = ".egg-info" in u_path or b".egg-info" in utf8_path
            if self.ignore_egg_info_dir and is_egg_info:
                return False
            # accept is either way checks out
            if os.path.exists(u_path) or os.path.exists(utf8_path):
                return True
        # this will catch any encode errors decoding u_path
        except UnicodeEncodeError:
            log.warn(enc_warn, path, sys.getfilesystemencoding())


class manifest_maker(sdist):
    template = "MANIFEST.in"

    def initialize_options(self):
        self.use_defaults = 1
        self.prune = 1
        self.manifest_only = 1
        self.force_manifest = 1
        self.ignore_egg_info_dir = False

    def finalize_options(self):
        pass

    def run(self):
        self.filelist = FileList(ignore_egg_info_dir=self.ignore_egg_info_dir)
        if not os.path.exists(self.manifest):
            self.write_manifest()  # it must exist so it'll get in the list
        self.add_defaults()
        if os.path.exists(self.template):
            self.read_template()
        self.add_license_files()
        self._add_referenced_files()
        self.prune_file_list()
        self.filelist.sort()
        self.filelist.remove_duplicates()
        self.write_manifest()

    def _manifest_normalize(self, path):
        path = unicode_utils.filesys_decode(path)
        return path.replace(os.sep, '/')

    def write_manifest(self):
        """
        Write the file list in 'self.filelist' to the manifest file
        named by 'self.manifest'.
        """
        self.filelist._repair()

        # Now _repairs should encodability, but not unicode
        files = [self._manifest_normalize(f) for f in self.filelist.files]
        msg = "writing manifest file '%s'" % self.manifest
        self.execute(write_file, (self.manifest, files), msg)

    def warn(self, msg):
        if not self._should_suppress_warning(msg):
            sdist.warn(self, msg)

    @staticmethod
    def _should_suppress_warning(msg):
        """
        suppress missing-file warnings from sdist
        """
        return re.match(r"standard file .*not found", msg)

    def add_defaults(self):
        sdist.add_defaults(self)
        self.filelist.append(self.template)
        self.filelist.append(self.manifest)
        rcfiles = list(walk_revctrl())
        if rcfiles:
            self.filelist.extend(rcfiles)
        elif os.path.exists(self.manifest):
            self.read_manifest()

        if os.path.exists("setup.py"):
            # setup.py should be included by default, even if it's not
            # the script called to create the sdist
            self.filelist.append("setup.py")

        ei_cmd = self.get_finalized_command('egg_info')
        self.filelist.graft(ei_cmd.egg_info)

    def add_license_files(self):
        license_files = self.distribution.metadata.license_files or []
        for lf in license_files:
            log.info("adding license file '%s'", lf)
        self.filelist.extend(license_files)

    def _add_referenced_files(self):
        """Add files referenced by the config (e.g. `file:` directive) to filelist"""
        referenced = getattr(self.distribution, '_referenced_files', [])
        # ^-- fallback if dist comes from distutils or is a custom class
        for rf in referenced:
            log.debug("adding file referenced by config '%s'", rf)
        self.filelist.extend(referenced)

    def prune_file_list(self):
        build = self.get_finalized_command('build')
        base_dir = self.distribution.get_fullname()
        self.filelist.prune(build.build_base)
        self.filelist.prune(base_dir)
        sep = re.escape(os.sep)
        self.filelist.exclude_pattern(
            r'(^|' + sep + r')(RCS|CVS|\.svn)' + sep, is_regex=1
        )

    def _safe_data_files(self, build_py):
        """
        The parent class implementation of this method
        (``sdist``) will try to include data files, which
        might cause recursion problems when
        ``include_package_data=True``.

        Therefore, avoid triggering any attempt of
        analyzing/building the manifest again.
        """
        if hasattr(build_py, 'get_data_files_without_manifest'):
            return build_py.get_data_files_without_manifest()

        SetuptoolsDeprecationWarning.emit(
            "`build_py` command does not inherit from setuptools' `build_py`.",
            """
            Custom 'build_py' does not implement 'get_data_files_without_manifest'.
            Please extend command classes from setuptools instead of distutils.
            """,
            see_url="https://peps.python.org/pep-0632/",
            # due_date not defined yet, old projects might still do it?
        )
        return build_py.get_data_files()


def write_file(filename, contents):
    """Create a file with the specified name and write 'contents' (a
    sequence of strings without line terminators) to it.
    """
    contents = "\n".join(contents)

    # assuming the contents has been vetted for utf-8 encoding
    contents = contents.encode("utf-8")

    with open(filename, "wb") as f:  # always write POSIX-style manifest
        f.write(contents)


def write_pkg_info(cmd, basename, filename):
    log.info("writing %s", filename)
    if not cmd.dry_run:
        metadata = cmd.distribution.metadata
        metadata.version, oldver = cmd.egg_version, metadata.version
        metadata.name, oldname = cmd.egg_name, metadata.name

        try:
            # write unescaped data to PKG-INFO, so older pkg_resources
            # can still parse it
            metadata.write_pkg_info(cmd.egg_info)
        finally:
            metadata.name, metadata.version = oldname, oldver

        safe = getattr(cmd.distribution, 'zip_safe', None)

        bdist_egg.write_safety_flag(cmd.egg_info, safe)


def warn_depends_obsolete(cmd, basename, filename):
    """
    Unused: left to avoid errors when updating (from source) from <= 67.8.
    Old installations have a .dist-info directory with the entry-point
    ``depends.txt = setuptools.command.egg_info:warn_depends_obsolete``.
    This may trigger errors when running the first egg_info in build_meta.
    TODO: Remove this function in a version sufficiently > 68.
    """


def _write_requirements(stream, reqs):
    lines = yield_lines(reqs or ())

    def append_cr(line):
        return line + '\n'

    lines = map(append_cr, lines)
    stream.writelines(lines)


def write_requirements(cmd, basename, filename):
    dist = cmd.distribution
    data = io.StringIO()
    _write_requirements(data, dist.install_requires)
    extras_require = dist.extras_require or {}
    for extra in sorted(extras_require):
        data.write('\n[{extra}]\n'.format(**vars()))
        _write_requirements(data, extras_require[extra])
    cmd.write_or_delete_file("requirements", filename, data.getvalue())


def write_setup_requirements(cmd, basename, filename):
    data = io.StringIO()
    _write_requirements(data, cmd.distribution.setup_requires)
    cmd.write_or_delete_file("setup-requirements", filename, data.getvalue())


def write_toplevel_names(cmd, basename, filename):
    pkgs = dict.fromkeys(
        [k.split('.', 1)[0] for k in cmd.distribution.iter_distribution_names()]
    )
    cmd.write_file("top-level names", filename, '\n'.join(sorted(pkgs)) + '\n')


def overwrite_arg(cmd, basename, filename):
    write_arg(cmd, basename, filename, True)


def write_arg(cmd, basename, filename, force=False):
    argname = os.path.splitext(basename)[0]
    value = getattr(cmd.distribution, argname, None)
    if value is not None:
        value = '\n'.join(value) + '\n'
    cmd.write_or_delete_file(argname, filename, value, force)


def write_entries(cmd, basename, filename):
    eps = _entry_points.load(cmd.distribution.entry_points)
    defn = _entry_points.render(eps)
    cmd.write_or_delete_file('entry points', filename, defn, True)


def _egg_basename(egg_name, egg_version, py_version=None, platform=None):
    """Compute filename of the output egg. Private API."""
    name = _normalization.filename_component(egg_name)
    version = _normalization.filename_component(egg_version)
    egg = f"{name}-{version}-py{py_version or PY_MAJOR}"
    if platform:
        egg += f"-{platform}"
    return egg


class EggInfoDeprecationWarning(SetuptoolsDeprecationWarning):
    """Deprecated behavior warning for EggInfo, bypassing suppression."""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/install.py0000644000175100001730000001277314467657412021343 0ustar00runnerdockerfrom distutils.errors import DistutilsArgError
import inspect
import glob
import platform
import distutils.command.install as orig

import setuptools
from ..warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning

# Prior to numpy 1.9, NumPy relies on the '_install' name, so provide it for
# now. See https://github.com/pypa/setuptools/issues/199/
_install = orig.install


class install(orig.install):
    """Use easy_install to install the package, w/dependencies"""

    user_options = orig.install.user_options + [
        ('old-and-unmanageable', None, "Try not to use this!"),
        (
            'single-version-externally-managed',
            None,
            "used by system package builders to create 'flat' eggs",
        ),
    ]
    boolean_options = orig.install.boolean_options + [
        'old-and-unmanageable',
        'single-version-externally-managed',
    ]
    new_commands = [
        ('install_egg_info', lambda self: True),
        ('install_scripts', lambda self: True),
    ]
    _nc = dict(new_commands)

    def initialize_options(self):
        SetuptoolsDeprecationWarning.emit(
            "setup.py install is deprecated.",
            """
            Please avoid running ``setup.py`` directly.
            Instead, use pypa/build, pypa/installer or other
            standards-based tools.
            """,
            see_url="https://blog.ganssle.io/articles/2021/10/setup-py-deprecated.html",
            # TODO: Document how to bootstrap setuptools without install
            #       (e.g. by unziping the wheel file)
            #       and then add a due_date to this warning.
        )

        orig.install.initialize_options(self)
        self.old_and_unmanageable = None
        self.single_version_externally_managed = None

    def finalize_options(self):
        orig.install.finalize_options(self)
        if self.root:
            self.single_version_externally_managed = True
        elif self.single_version_externally_managed:
            if not self.root and not self.record:
                raise DistutilsArgError(
                    "You must specify --record or --root when building system"
                    " packages"
                )

    def handle_extra_path(self):
        if self.root or self.single_version_externally_managed:
            # explicit backward-compatibility mode, allow extra_path to work
            return orig.install.handle_extra_path(self)

        # Ignore extra_path when installing an egg (or being run by another
        # command without --root or --single-version-externally-managed
        self.path_file = None
        self.extra_dirs = ''

    def run(self):
        # Explicit request for old-style install?  Just do it
        if self.old_and_unmanageable or self.single_version_externally_managed:
            return orig.install.run(self)

        if not self._called_from_setup(inspect.currentframe()):
            # Run in backward-compatibility mode to support bdist_* commands.
            orig.install.run(self)
        else:
            self.do_egg_install()

    @staticmethod
    def _called_from_setup(run_frame):
        """
        Attempt to detect whether run() was called from setup() or by another
        command.  If called by setup(), the parent caller will be the
        'run_command' method in 'distutils.dist', and *its* caller will be
        the 'run_commands' method.  If called any other way, the
        immediate caller *might* be 'run_command', but it won't have been
        called by 'run_commands'. Return True in that case or if a call stack
        is unavailable. Return False otherwise.
        """
        if run_frame is None:
            msg = "Call stack not available. bdist_* commands may fail."
            SetuptoolsWarning.emit(msg)
            if platform.python_implementation() == 'IronPython':
                msg = "For best results, pass -X:Frames to enable call stack."
                SetuptoolsWarning.emit(msg)
            return True

        frames = inspect.getouterframes(run_frame)
        for frame in frames[2:4]:
            (caller,) = frame[:1]
            info = inspect.getframeinfo(caller)
            caller_module = caller.f_globals.get('__name__', '')

            if caller_module == "setuptools.dist" and info.function == "run_command":
                # Starting from v61.0.0 setuptools overwrites dist.run_command
                continue

            return caller_module == 'distutils.dist' and info.function == 'run_commands'

    def do_egg_install(self):
        easy_install = self.distribution.get_command_class('easy_install')

        cmd = easy_install(
            self.distribution,
            args="x",
            root=self.root,
            record=self.record,
        )
        cmd.ensure_finalized()  # finalize before bdist_egg munges install cmd
        cmd.always_copy_from = '.'  # make sure local-dir eggs get installed

        # pick up setup-dir .egg files only: no .egg-info
        cmd.package_index.scan(glob.glob('*.egg'))

        self.run_command('bdist_egg')
        args = [self.distribution.get_command_obj('bdist_egg').egg_output]

        if setuptools.bootstrap_install_from:
            # Bootstrap self-installation of setuptools
            args.insert(0, setuptools.bootstrap_install_from)

        cmd.args = args
        cmd.run(show_deprecation=False)
        setuptools.bootstrap_install_from = None


# XXX Python 3.1 doesn't see _nc if this is inside the class
install.sub_commands = [
    cmd for cmd in orig.install.sub_commands if cmd[0] not in install._nc
] + install.new_commands
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/install_egg_info.py0000644000175100001730000000402214467657412023164 0ustar00runnerdockerfrom distutils import log, dir_util
import os

from setuptools import Command
from setuptools import namespaces
from setuptools.archive_util import unpack_archive
from .._path import ensure_directory


class install_egg_info(namespaces.Installer, Command):
    """Install an .egg-info directory for the package"""

    description = "Install an .egg-info directory for the package"

    user_options = [
        ('install-dir=', 'd', "directory to install to"),
    ]

    def initialize_options(self):
        self.install_dir = None

    def finalize_options(self):
        self.set_undefined_options('install_lib', ('install_dir', 'install_dir'))
        ei_cmd = self.get_finalized_command("egg_info")
        basename = f"{ei_cmd._get_egg_basename()}.egg-info"
        self.source = ei_cmd.egg_info
        self.target = os.path.join(self.install_dir, basename)
        self.outputs = []

    def run(self):
        self.run_command('egg_info')
        if os.path.isdir(self.target) and not os.path.islink(self.target):
            dir_util.remove_tree(self.target, dry_run=self.dry_run)
        elif os.path.exists(self.target):
            self.execute(os.unlink, (self.target,), "Removing " + self.target)
        if not self.dry_run:
            ensure_directory(self.target)
        self.execute(self.copytree, (), "Copying %s to %s" % (self.source, self.target))
        self.install_namespaces()

    def get_outputs(self):
        return self.outputs

    def copytree(self):
        # Copy the .egg-info tree to site-packages
        def skimmer(src, dst):
            # filter out source-control directories; note that 'src' is always
            # a '/'-separated path, regardless of platform.  'dst' is a
            # platform-specific path.
            for skip in '.svn/', 'CVS/':
                if src.startswith(skip) or '/' + skip in src:
                    return None
            self.outputs.append(dst)
            log.debug("Copying %s to %s", src, dst)
            return dst

        unpack_archive(self.source, self.target, skimmer)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/install_lib.py0000644000175100001730000000743614467657412022171 0ustar00runnerdockerimport os
import sys
from itertools import product, starmap
import distutils.command.install_lib as orig


class install_lib(orig.install_lib):
    """Don't add compiled flags to filenames of non-Python files"""

    def run(self):
        self.build()
        outfiles = self.install()
        if outfiles is not None:
            # always compile, in case we have any extension stubs to deal with
            self.byte_compile(outfiles)

    def get_exclusions(self):
        """
        Return a collections.Sized collections.Container of paths to be
        excluded for single_version_externally_managed installations.
        """
        all_packages = (
            pkg
            for ns_pkg in self._get_SVEM_NSPs()
            for pkg in self._all_packages(ns_pkg)
        )

        excl_specs = product(all_packages, self._gen_exclusion_paths())
        return set(starmap(self._exclude_pkg_path, excl_specs))

    def _exclude_pkg_path(self, pkg, exclusion_path):
        """
        Given a package name and exclusion path within that package,
        compute the full exclusion path.
        """
        parts = pkg.split('.') + [exclusion_path]
        return os.path.join(self.install_dir, *parts)

    @staticmethod
    def _all_packages(pkg_name):
        """
        >>> list(install_lib._all_packages('foo.bar.baz'))
        ['foo.bar.baz', 'foo.bar', 'foo']
        """
        while pkg_name:
            yield pkg_name
            pkg_name, sep, child = pkg_name.rpartition('.')

    def _get_SVEM_NSPs(self):
        """
        Get namespace packages (list) but only for
        single_version_externally_managed installations and empty otherwise.
        """
        # TODO: is it necessary to short-circuit here? i.e. what's the cost
        # if get_finalized_command is called even when namespace_packages is
        # False?
        if not self.distribution.namespace_packages:
            return []

        install_cmd = self.get_finalized_command('install')
        svem = install_cmd.single_version_externally_managed

        return self.distribution.namespace_packages if svem else []

    @staticmethod
    def _gen_exclusion_paths():
        """
        Generate file paths to be excluded for namespace packages (bytecode
        cache files).
        """
        # always exclude the package module itself
        yield '__init__.py'

        yield '__init__.pyc'
        yield '__init__.pyo'

        if not hasattr(sys, 'implementation'):
            return

        base = os.path.join('__pycache__', '__init__.' + sys.implementation.cache_tag)
        yield base + '.pyc'
        yield base + '.pyo'
        yield base + '.opt-1.pyc'
        yield base + '.opt-2.pyc'

    def copy_tree(
        self,
        infile,
        outfile,
        preserve_mode=1,
        preserve_times=1,
        preserve_symlinks=0,
        level=1,
    ):
        assert preserve_mode and preserve_times and not preserve_symlinks
        exclude = self.get_exclusions()

        if not exclude:
            return orig.install_lib.copy_tree(self, infile, outfile)

        # Exclude namespace package __init__.py* files from the output

        from setuptools.archive_util import unpack_directory
        from distutils import log

        outfiles = []

        def pf(src, dst):
            if dst in exclude:
                log.warn("Skipping installation of %s (namespace package)", dst)
                return False

            log.info("copying %s -> %s", src, os.path.dirname(dst))
            outfiles.append(dst)
            return dst

        unpack_directory(infile, outfile, pf)
        return outfiles

    def get_outputs(self):
        outputs = orig.install_lib.get_outputs(self)
        exclude = self.get_exclusions()
        if exclude:
            return [f for f in outputs if f not in exclude]
        return outputs
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/install_scripts.py0000644000175100001730000000446714467657412023113 0ustar00runnerdockerfrom distutils import log
import distutils.command.install_scripts as orig
import os
import sys

from .._path import ensure_directory


class install_scripts(orig.install_scripts):
    """Do normal script install, plus any egg_info wrapper scripts"""

    def initialize_options(self):
        orig.install_scripts.initialize_options(self)
        self.no_ep = False

    def run(self):
        self.run_command("egg_info")
        if self.distribution.scripts:
            orig.install_scripts.run(self)  # run first to set up self.outfiles
        else:
            self.outfiles = []
        if self.no_ep:
            # don't install entry point scripts into .egg file!
            return
        self._install_ep_scripts()

    def _install_ep_scripts(self):
        # Delay import side-effects
        from pkg_resources import Distribution, PathMetadata
        from . import easy_install as ei

        ei_cmd = self.get_finalized_command("egg_info")
        dist = Distribution(
            ei_cmd.egg_base,
            PathMetadata(ei_cmd.egg_base, ei_cmd.egg_info),
            ei_cmd.egg_name,
            ei_cmd.egg_version,
        )
        bs_cmd = self.get_finalized_command('build_scripts')
        exec_param = getattr(bs_cmd, 'executable', None)
        writer = ei.ScriptWriter
        if exec_param == sys.executable:
            # In case the path to the Python executable contains a space, wrap
            # it so it's not split up.
            exec_param = [exec_param]
        # resolve the writer to the environment
        writer = writer.best()
        cmd = writer.command_spec_class.best().from_param(exec_param)
        for args in writer.get_args(dist, cmd.as_header()):
            self.write_script(*args)

    def write_script(self, script_name, contents, mode="t", *ignored):
        """Write an executable file to the scripts directory"""
        from setuptools.command.easy_install import chmod, current_umask

        log.info("Installing %s script to %s", script_name, self.install_dir)
        target = os.path.join(self.install_dir, script_name)
        self.outfiles.append(target)

        mask = current_umask()
        if not self.dry_run:
            ensure_directory(target)
            f = open(target, "w" + mode)
            f.write(contents)
            f.close()
            chmod(target, 0o777 - mask)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/launcher manifest.xml0000644000175100001730000000116414467657412023425 0ustar00runnerdocker

    
    
    
        
            
                
            
        
    

././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/register.py0000644000175100001730000000072414467657412021512 0ustar00runnerdockerfrom distutils import log
import distutils.command.register as orig

from setuptools.errors import RemovedCommandError


class register(orig.register):
    """Formerly used to register packages on PyPI."""

    def run(self):
        msg = (
            "The register command has been removed, use twine to upload "
            + "instead (https://pypi.org/p/twine)"
        )

        self.announce("ERROR: " + msg, log.ERROR)

        raise RemovedCommandError(msg)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/rotate.py0000644000175100001730000000406114467657412021162 0ustar00runnerdockerfrom distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
import os
import shutil

from setuptools import Command


class rotate(Command):
    """Delete older distributions"""

    description = "delete older distributions, keeping N newest files"
    user_options = [
        ('match=', 'm', "patterns to match (required)"),
        ('dist-dir=', 'd', "directory where the distributions are"),
        ('keep=', 'k', "number of matching distributions to keep"),
    ]

    boolean_options = []

    def initialize_options(self):
        self.match = None
        self.dist_dir = None
        self.keep = None

    def finalize_options(self):
        if self.match is None:
            raise DistutilsOptionError(
                "Must specify one or more (comma-separated) match patterns "
                "(e.g. '.zip' or '.egg')"
            )
        if self.keep is None:
            raise DistutilsOptionError("Must specify number of files to keep")
        try:
            self.keep = int(self.keep)
        except ValueError as e:
            raise DistutilsOptionError("--keep must be an integer") from e
        if isinstance(self.match, str):
            self.match = [convert_path(p.strip()) for p in self.match.split(',')]
        self.set_undefined_options('bdist', ('dist_dir', 'dist_dir'))

    def run(self):
        self.run_command("egg_info")
        from glob import glob

        for pattern in self.match:
            pattern = self.distribution.get_name() + '*' + pattern
            files = glob(os.path.join(self.dist_dir, pattern))
            files = [(os.path.getmtime(f), f) for f in files]
            files.sort()
            files.reverse()

            log.info("%d file(s) matching %s", len(files), pattern)
            files = files[self.keep :]
            for t, f in files:
                log.info("Deleting %s", f)
                if not self.dry_run:
                    if os.path.isdir(f):
                        shutil.rmtree(f)
                    else:
                        os.unlink(f)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/saveopts.py0000644000175100001730000000122114467657412021523 0ustar00runnerdockerfrom setuptools.command.setopt import edit_config, option_base


class saveopts(option_base):
    """Save command-line options to a file"""

    description = "save supplied options to setup.cfg or other config file"

    def run(self):
        dist = self.distribution
        settings = {}

        for cmd in dist.command_options:
            if cmd == 'saveopts':
                continue  # don't save our own options!

            for opt, (src, val) in dist.get_option_dict(cmd).items():
                if src == "command line":
                    settings.setdefault(cmd, {})[opt] = val

        edit_config(self.filename, settings, self.dry_run)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/sdist.py0000644000175100001730000001567214467657412021024 0ustar00runnerdockerfrom distutils import log
import distutils.command.sdist as orig
import os
import sys
import io
import contextlib
from itertools import chain

from .._importlib import metadata
from .build import _ORIGINAL_SUBCOMMANDS

_default_revctrl = list


def walk_revctrl(dirname=''):
    """Find all files under revision control"""
    for ep in metadata.entry_points(group='setuptools.file_finders'):
        for item in ep.load()(dirname):
            yield item


class sdist(orig.sdist):
    """Smart sdist that finds anything supported by revision control"""

    user_options = [
        ('formats=', None, "formats for source distribution (comma-separated list)"),
        (
            'keep-temp',
            'k',
            "keep the distribution tree around after creating " + "archive file(s)",
        ),
        (
            'dist-dir=',
            'd',
            "directory to put the source distribution archive(s) in " "[default: dist]",
        ),
        (
            'owner=',
            'u',
            "Owner name used when creating a tar file [default: current user]",
        ),
        (
            'group=',
            'g',
            "Group name used when creating a tar file [default: current group]",
        ),
    ]

    negative_opt = {}

    README_EXTENSIONS = ['', '.rst', '.txt', '.md']
    READMES = tuple('README{0}'.format(ext) for ext in README_EXTENSIONS)

    def run(self):
        self.run_command('egg_info')
        ei_cmd = self.get_finalized_command('egg_info')
        self.filelist = ei_cmd.filelist
        self.filelist.append(os.path.join(ei_cmd.egg_info, 'SOURCES.txt'))
        self.check_readme()

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        self.make_distribution()

        dist_files = getattr(self.distribution, 'dist_files', [])
        for file in self.archive_files:
            data = ('sdist', '', file)
            if data not in dist_files:
                dist_files.append(data)

    def initialize_options(self):
        orig.sdist.initialize_options(self)

        self._default_to_gztar()

    def _default_to_gztar(self):
        # only needed on Python prior to 3.6.
        if sys.version_info >= (3, 6, 0, 'beta', 1):
            return
        self.formats = ['gztar']

    def make_distribution(self):
        """
        Workaround for #516
        """
        with self._remove_os_link():
            orig.sdist.make_distribution(self)

    @staticmethod
    @contextlib.contextmanager
    def _remove_os_link():
        """
        In a context, remove and restore os.link if it exists
        """

        class NoValue:
            pass

        orig_val = getattr(os, 'link', NoValue)
        try:
            del os.link
        except Exception:
            pass
        try:
            yield
        finally:
            if orig_val is not NoValue:
                setattr(os, 'link', orig_val)

    def add_defaults(self):
        super().add_defaults()
        self._add_defaults_build_sub_commands()

    def _add_defaults_optional(self):
        super()._add_defaults_optional()
        if os.path.isfile('pyproject.toml'):
            self.filelist.append('pyproject.toml')

    def _add_defaults_python(self):
        """getting python files"""
        if self.distribution.has_pure_modules():
            build_py = self.get_finalized_command('build_py')
            self.filelist.extend(build_py.get_source_files())
            self._add_data_files(self._safe_data_files(build_py))

    def _add_defaults_build_sub_commands(self):
        build = self.get_finalized_command("build")
        missing_cmds = set(build.get_sub_commands()) - _ORIGINAL_SUBCOMMANDS
        # ^-- the original built-in sub-commands are already handled by default.
        cmds = (self.get_finalized_command(c) for c in missing_cmds)
        files = (c.get_source_files() for c in cmds if hasattr(c, "get_source_files"))
        self.filelist.extend(chain.from_iterable(files))

    def _safe_data_files(self, build_py):
        """
        Since the ``sdist`` class is also used to compute the MANIFEST
        (via :obj:`setuptools.command.egg_info.manifest_maker`),
        there might be recursion problems when trying to obtain the list of
        data_files and ``include_package_data=True`` (which in turn depends on
        the files included in the MANIFEST).

        To avoid that, ``manifest_maker`` should be able to overwrite this
        method and avoid recursive attempts to build/analyze the MANIFEST.
        """
        return build_py.data_files

    def _add_data_files(self, data_files):
        """
        Add data files as found in build_py.data_files.
        """
        self.filelist.extend(
            os.path.join(src_dir, name)
            for _, src_dir, _, filenames in data_files
            for name in filenames
        )

    def _add_defaults_data_files(self):
        try:
            super()._add_defaults_data_files()
        except TypeError:
            log.warn("data_files contains unexpected objects")

    def check_readme(self):
        for f in self.READMES:
            if os.path.exists(f):
                return
        else:
            self.warn(
                "standard file not found: should have one of " + ', '.join(self.READMES)
            )

    def make_release_tree(self, base_dir, files):
        orig.sdist.make_release_tree(self, base_dir, files)

        # Save any egg_info command line options used to create this sdist
        dest = os.path.join(base_dir, 'setup.cfg')
        if hasattr(os, 'link') and os.path.exists(dest):
            # unlink and re-copy, since it might be hard-linked, and
            # we don't want to change the source version
            os.unlink(dest)
            self.copy_file('setup.cfg', dest)

        self.get_finalized_command('egg_info').save_version_info(dest)

    def _manifest_is_not_generated(self):
        # check for special comment used in 2.7.1 and higher
        if not os.path.isfile(self.manifest):
            return False

        with io.open(self.manifest, 'rb') as fp:
            first_line = fp.readline()
        return first_line != '# file GENERATED by distutils, do NOT edit\n'.encode()

    def read_manifest(self):
        """Read the manifest file (named by 'self.manifest') and use it to
        fill in 'self.filelist', the list of files to include in the source
        distribution.
        """
        log.info("reading manifest file '%s'", self.manifest)
        manifest = open(self.manifest, 'rb')
        for line in manifest:
            # The manifest must contain UTF-8. See #303.
            try:
                line = line.decode('UTF-8')
            except UnicodeDecodeError:
                log.warn("%r not UTF-8 decodable -- skipping" % line)
                continue
            # ignore comments and blank lines
            line = line.strip()
            if line.startswith('#') or not line:
                continue
            self.filelist.append(line)
        manifest.close()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/setopt.py0000644000175100001730000001147714467657412021213 0ustar00runnerdockerfrom distutils.util import convert_path
from distutils import log
from distutils.errors import DistutilsOptionError
import distutils
import os
import configparser

from setuptools import Command

__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']


def config_file(kind="local"):
    """Get the filename of the distutils, local, global, or per-user config

    `kind` must be one of "local", "global", or "user"
    """
    if kind == 'local':
        return 'setup.cfg'
    if kind == 'global':
        return os.path.join(os.path.dirname(distutils.__file__), 'distutils.cfg')
    if kind == 'user':
        dot = os.name == 'posix' and '.' or ''
        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
    raise ValueError("config_file() type must be 'local', 'global', or 'user'", kind)


def edit_config(filename, settings, dry_run=False):
    """Edit a configuration file to include `settings`

    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
    command/section name.  A ``None`` value means to delete the entire section,
    while a dictionary lists settings to be changed or deleted in that section.
    A setting of ``None`` means to delete that setting.
    """
    log.debug("Reading configuration from %s", filename)
    opts = configparser.RawConfigParser()
    opts.optionxform = lambda x: x
    opts.read([filename])
    for section, options in settings.items():
        if options is None:
            log.info("Deleting section [%s] from %s", section, filename)
            opts.remove_section(section)
        else:
            if not opts.has_section(section):
                log.debug("Adding new section [%s] to %s", section, filename)
                opts.add_section(section)
            for option, value in options.items():
                if value is None:
                    log.debug("Deleting %s.%s from %s", section, option, filename)
                    opts.remove_option(section, option)
                    if not opts.options(section):
                        log.info(
                            "Deleting empty [%s] section from %s", section, filename
                        )
                        opts.remove_section(section)
                else:
                    log.debug(
                        "Setting %s.%s to %r in %s", section, option, value, filename
                    )
                    opts.set(section, option, value)

    log.info("Writing %s", filename)
    if not dry_run:
        with open(filename, 'w') as f:
            opts.write(f)


class option_base(Command):
    """Abstract base class for commands that mess with config files"""

    user_options = [
        ('global-config', 'g', "save options to the site-wide distutils.cfg file"),
        ('user-config', 'u', "save options to the current user's pydistutils.cfg file"),
        ('filename=', 'f', "configuration file to use (default=setup.cfg)"),
    ]

    boolean_options = [
        'global-config',
        'user-config',
    ]

    def initialize_options(self):
        self.global_config = None
        self.user_config = None
        self.filename = None

    def finalize_options(self):
        filenames = []
        if self.global_config:
            filenames.append(config_file('global'))
        if self.user_config:
            filenames.append(config_file('user'))
        if self.filename is not None:
            filenames.append(self.filename)
        if not filenames:
            filenames.append(config_file('local'))
        if len(filenames) > 1:
            raise DistutilsOptionError(
                "Must specify only one configuration file option", filenames
            )
        (self.filename,) = filenames


class setopt(option_base):
    """Save command-line options to a file"""

    description = "set an option in setup.cfg or another config file"

    user_options = [
        ('command=', 'c', 'command to set an option for'),
        ('option=', 'o', 'option to set'),
        ('set-value=', 's', 'value of the option'),
        ('remove', 'r', 'remove (unset) the value'),
    ] + option_base.user_options

    boolean_options = option_base.boolean_options + ['remove']

    def initialize_options(self):
        option_base.initialize_options(self)
        self.command = None
        self.option = None
        self.set_value = None
        self.remove = None

    def finalize_options(self):
        option_base.finalize_options(self)
        if self.command is None or self.option is None:
            raise DistutilsOptionError("Must specify --command *and* --option")
        if self.set_value is None and not self.remove:
            raise DistutilsOptionError("Must specify --set-value or --remove")

    def run(self):
        edit_config(
            self.filename,
            {self.command: {self.option.replace('-', '_'): self.set_value}},
            self.dry_run,
        )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/test.py0000644000175100001730000001764514467657412020657 0ustar00runnerdockerimport os
import operator
import sys
import contextlib
import itertools
import unittest
from distutils.errors import DistutilsError, DistutilsOptionError
from distutils import log
from unittest import TestLoader

from pkg_resources import (
    resource_listdir,
    resource_exists,
    normalize_path,
    working_set,
    evaluate_marker,
    add_activation_listener,
    require,
)
from .._importlib import metadata
from setuptools import Command
from setuptools.extern.more_itertools import unique_everseen
from setuptools.extern.jaraco.functools import pass_none


class ScanningLoader(TestLoader):
    def __init__(self):
        TestLoader.__init__(self)
        self._visited = set()

    def loadTestsFromModule(self, module, pattern=None):
        """Return a suite of all tests cases contained in the given module

        If the module is a package, load tests from all the modules in it.
        If the module has an ``additional_tests`` function, call it and add
        the return value to the tests.
        """
        if module in self._visited:
            return None
        self._visited.add(module)

        tests = []
        tests.append(TestLoader.loadTestsFromModule(self, module))

        if hasattr(module, "additional_tests"):
            tests.append(module.additional_tests())

        if hasattr(module, '__path__'):
            for file in resource_listdir(module.__name__, ''):
                if file.endswith('.py') and file != '__init__.py':
                    submodule = module.__name__ + '.' + file[:-3]
                else:
                    if resource_exists(module.__name__, file + '/__init__.py'):
                        submodule = module.__name__ + '.' + file
                    else:
                        continue
                tests.append(self.loadTestsFromName(submodule))

        if len(tests) != 1:
            return self.suiteClass(tests)
        else:
            return tests[0]  # don't create a nested suite for only one return


# adapted from jaraco.classes.properties:NonDataProperty
class NonDataProperty:
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return self.fget(obj)


class test(Command):
    """Command to run unit tests after in-place build"""

    description = "run unit tests after in-place build (deprecated)"

    user_options = [
        ('test-module=', 'm', "Run 'test_suite' in specified module"),
        (
            'test-suite=',
            's',
            "Run single test, case or suite (e.g. 'module.test_suite')",
        ),
        ('test-runner=', 'r', "Test runner to use"),
    ]

    def initialize_options(self):
        self.test_suite = None
        self.test_module = None
        self.test_loader = None
        self.test_runner = None

    def finalize_options(self):
        if self.test_suite and self.test_module:
            msg = "You may specify a module or a suite, but not both"
            raise DistutilsOptionError(msg)

        if self.test_suite is None:
            if self.test_module is None:
                self.test_suite = self.distribution.test_suite
            else:
                self.test_suite = self.test_module + ".test_suite"

        if self.test_loader is None:
            self.test_loader = getattr(self.distribution, 'test_loader', None)
        if self.test_loader is None:
            self.test_loader = "setuptools.command.test:ScanningLoader"
        if self.test_runner is None:
            self.test_runner = getattr(self.distribution, 'test_runner', None)

    @NonDataProperty
    def test_args(self):
        return list(self._test_args())

    def _test_args(self):
        if not self.test_suite:
            yield 'discover'
        if self.verbose:
            yield '--verbose'
        if self.test_suite:
            yield self.test_suite

    def with_project_on_sys_path(self, func):
        """
        Backward compatibility for project_on_sys_path context.
        """
        with self.project_on_sys_path():
            func()

    @contextlib.contextmanager
    def project_on_sys_path(self, include_dists=[]):
        self.run_command('egg_info')

        # Build extensions in-place
        self.reinitialize_command('build_ext', inplace=1)
        self.run_command('build_ext')

        ei_cmd = self.get_finalized_command("egg_info")

        old_path = sys.path[:]
        old_modules = sys.modules.copy()

        try:
            project_path = normalize_path(ei_cmd.egg_base)
            sys.path.insert(0, project_path)
            working_set.__init__()
            add_activation_listener(lambda dist: dist.activate())
            require('%s==%s' % (ei_cmd.egg_name, ei_cmd.egg_version))
            with self.paths_on_pythonpath([project_path]):
                yield
        finally:
            sys.path[:] = old_path
            sys.modules.clear()
            sys.modules.update(old_modules)
            working_set.__init__()

    @staticmethod
    @contextlib.contextmanager
    def paths_on_pythonpath(paths):
        """
        Add the indicated paths to the head of the PYTHONPATH environment
        variable so that subprocesses will also see the packages at
        these paths.

        Do this in a context that restores the value on exit.
        """
        nothing = object()
        orig_pythonpath = os.environ.get('PYTHONPATH', nothing)
        current_pythonpath = os.environ.get('PYTHONPATH', '')
        try:
            prefix = os.pathsep.join(unique_everseen(paths))
            to_join = filter(None, [prefix, current_pythonpath])
            new_path = os.pathsep.join(to_join)
            if new_path:
                os.environ['PYTHONPATH'] = new_path
            yield
        finally:
            if orig_pythonpath is nothing:
                os.environ.pop('PYTHONPATH', None)
            else:
                os.environ['PYTHONPATH'] = orig_pythonpath

    @staticmethod
    def install_dists(dist):
        """
        Install the requirements indicated by self.distribution and
        return an iterable of the dists that were built.
        """
        ir_d = dist.fetch_build_eggs(dist.install_requires)
        tr_d = dist.fetch_build_eggs(dist.tests_require or [])
        er_d = dist.fetch_build_eggs(
            v
            for k, v in dist.extras_require.items()
            if k.startswith(':') and evaluate_marker(k[1:])
        )
        return itertools.chain(ir_d, tr_d, er_d)

    def run(self):
        self.announce(
            "WARNING: Testing via this command is deprecated and will be "
            "removed in a future version. Users looking for a generic test "
            "entry point independent of test runner are encouraged to use "
            "tox.",
            log.WARN,
        )

        installed_dists = self.install_dists(self.distribution)

        cmd = ' '.join(self._argv)
        if self.dry_run:
            self.announce('skipping "%s" (dry run)' % cmd)
            return

        self.announce('running "%s"' % cmd)

        paths = map(operator.attrgetter('location'), installed_dists)
        with self.paths_on_pythonpath(paths):
            with self.project_on_sys_path():
                self.run_tests()

    def run_tests(self):
        test = unittest.main(
            None,
            None,
            self._argv,
            testLoader=self._resolve_as_ep(self.test_loader),
            testRunner=self._resolve_as_ep(self.test_runner),
            exit=False,
        )
        if not test.result.wasSuccessful():
            msg = 'Test failed: %s' % test.result
            self.announce(msg, log.ERROR)
            raise DistutilsError(msg)

    @property
    def _argv(self):
        return ['unittest'] + self.test_args

    @staticmethod
    @pass_none
    def _resolve_as_ep(val):
        """
        Load the indicated attribute value, called, as a as if it were
        specified as an entry point.
        """
        return metadata.EntryPoint(value=val, name=None, group=None).load()()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/upload.py0000644000175100001730000000071614467657412021153 0ustar00runnerdockerfrom distutils import log
from distutils.command import upload as orig

from setuptools.errors import RemovedCommandError


class upload(orig.upload):
    """Formerly used to upload packages to PyPI."""

    def run(self):
        msg = (
            "The upload command has been removed, use twine to upload "
            + "instead (https://pypi.org/p/twine)"
        )

        self.announce("ERROR: " + msg, log.ERROR)
        raise RemovedCommandError(msg)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/command/upload_docs.py0000644000175100001730000001713514467657412022166 0ustar00runnerdocker"""upload_docs

Implements a Distutils 'upload_docs' subcommand (upload documentation to
sites other than PyPi such as devpi).
"""

from base64 import standard_b64encode
from distutils import log
from distutils.errors import DistutilsOptionError
import os
import socket
import zipfile
import tempfile
import shutil
import itertools
import functools
import http.client
import urllib.parse

from .._importlib import metadata
from ..warnings import SetuptoolsDeprecationWarning

from .upload import upload


def _encode(s):
    return s.encode('utf-8', 'surrogateescape')


class upload_docs(upload):
    # override the default repository as upload_docs isn't
    # supported by Warehouse (and won't be).
    DEFAULT_REPOSITORY = 'https://pypi.python.org/pypi/'

    description = 'Upload documentation to sites other than PyPi such as devpi'

    user_options = [
        (
            'repository=',
            'r',
            "url of repository [default: %s]" % upload.DEFAULT_REPOSITORY,
        ),
        ('show-response', None, 'display full response text from server'),
        ('upload-dir=', None, 'directory to upload'),
    ]
    boolean_options = upload.boolean_options

    def has_sphinx(self):
        return bool(
            self.upload_dir is None
            and metadata.entry_points(group='distutils.commands', name='build_sphinx')
        )

    sub_commands = [('build_sphinx', has_sphinx)]

    def initialize_options(self):
        upload.initialize_options(self)
        self.upload_dir = None
        self.target_dir = None

    def finalize_options(self):
        log.warn(
            "Upload_docs command is deprecated. Use Read the Docs "
            "(https://readthedocs.org) instead."
        )
        upload.finalize_options(self)
        if self.upload_dir is None:
            if self.has_sphinx():
                build_sphinx = self.get_finalized_command('build_sphinx')
                self.target_dir = dict(build_sphinx.builder_target_dirs)['html']
            else:
                build = self.get_finalized_command('build')
                self.target_dir = os.path.join(build.build_base, 'docs')
        else:
            self.ensure_dirname('upload_dir')
            self.target_dir = self.upload_dir
        self.announce('Using upload directory %s' % self.target_dir)

    def create_zipfile(self, filename):
        zip_file = zipfile.ZipFile(filename, "w")
        try:
            self.mkpath(self.target_dir)  # just in case
            for root, dirs, files in os.walk(self.target_dir):
                if root == self.target_dir and not files:
                    tmpl = "no files found in upload directory '%s'"
                    raise DistutilsOptionError(tmpl % self.target_dir)
                for name in files:
                    full = os.path.join(root, name)
                    relative = root[len(self.target_dir) :].lstrip(os.path.sep)
                    dest = os.path.join(relative, name)
                    zip_file.write(full, dest)
        finally:
            zip_file.close()

    def run(self):
        SetuptoolsDeprecationWarning.emit(
            "Deprecated command",
            """
            upload_docs is deprecated and will be removed in a future version.
            Instead, use tools like devpi and Read the Docs; or lower level tools like
            httpie and curl to interact directly with your hosting service API.
            """,
            due_date=(2023, 9, 26),  # warning introduced in 27 Jul 2022
        )

        # Run sub commands
        for cmd_name in self.get_sub_commands():
            self.run_command(cmd_name)

        tmp_dir = tempfile.mkdtemp()
        name = self.distribution.metadata.get_name()
        zip_file = os.path.join(tmp_dir, "%s.zip" % name)
        try:
            self.create_zipfile(zip_file)
            self.upload_file(zip_file)
        finally:
            shutil.rmtree(tmp_dir)

    @staticmethod
    def _build_part(item, sep_boundary):
        key, values = item
        title = '\nContent-Disposition: form-data; name="%s"' % key
        # handle multiple entries for the same name
        if not isinstance(values, list):
            values = [values]
        for value in values:
            if isinstance(value, tuple):
                title += '; filename="%s"' % value[0]
                value = value[1]
            else:
                value = _encode(value)
            yield sep_boundary
            yield _encode(title)
            yield b"\n\n"
            yield value
            if value and value[-1:] == b'\r':
                yield b'\n'  # write an extra newline (lurve Macs)

    @classmethod
    def _build_multipart(cls, data):
        """
        Build up the MIME payload for the POST data
        """
        boundary = '--------------GHSKFJDLGDS7543FJKLFHRE75642756743254'
        sep_boundary = b'\n--' + boundary.encode('ascii')
        end_boundary = sep_boundary + b'--'
        end_items = (
            end_boundary,
            b"\n",
        )
        builder = functools.partial(
            cls._build_part,
            sep_boundary=sep_boundary,
        )
        part_groups = map(builder, data.items())
        parts = itertools.chain.from_iterable(part_groups)
        body_items = itertools.chain(parts, end_items)
        content_type = 'multipart/form-data; boundary=%s' % boundary
        return b''.join(body_items), content_type

    def upload_file(self, filename):
        with open(filename, 'rb') as f:
            content = f.read()
        meta = self.distribution.metadata
        data = {
            ':action': 'doc_upload',
            'name': meta.get_name(),
            'content': (os.path.basename(filename), content),
        }
        # set up the authentication
        credentials = _encode(self.username + ':' + self.password)
        credentials = standard_b64encode(credentials).decode('ascii')
        auth = "Basic " + credentials

        body, ct = self._build_multipart(data)

        msg = "Submitting documentation to %s" % (self.repository)
        self.announce(msg, log.INFO)

        # build the Request
        # We can't use urllib2 since we need to send the Basic
        # auth right with the first request
        schema, netloc, url, params, query, fragments = urllib.parse.urlparse(
            self.repository
        )
        assert not params and not query and not fragments
        if schema == 'http':
            conn = http.client.HTTPConnection(netloc)
        elif schema == 'https':
            conn = http.client.HTTPSConnection(netloc)
        else:
            raise AssertionError("unsupported schema " + schema)

        data = ''
        try:
            conn.connect()
            conn.putrequest("POST", url)
            content_type = ct
            conn.putheader('Content-type', content_type)
            conn.putheader('Content-length', str(len(body)))
            conn.putheader('Authorization', auth)
            conn.endheaders()
            conn.send(body)
        except socket.error as e:
            self.announce(str(e), log.ERROR)
            return

        r = conn.getresponse()
        if r.status == 200:
            msg = 'Server response (%s): %s' % (r.status, r.reason)
            self.announce(msg, log.INFO)
        elif r.status == 301:
            location = r.getheader('Location')
            if location is None:
                location = 'https://pythonhosted.org/%s/' % meta.get_name()
            msg = 'Upload successful. Visit %s' % location
            self.announce(msg, log.INFO)
        else:
            msg = 'Upload failed (%s): %s' % (r.status, r.reason)
            self.announce(msg, log.ERROR)
        if self.show_response:
            print('-' * 75, r.read(), '-' * 75)
././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.543551
setuptools-68.1.2/setuptools/config/0000755000175100001730000000000014467657444017145 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/__init__.py0000644000175100001730000000273214467657412021255 0ustar00runnerdocker"""For backward compatibility, expose main functions from
``setuptools.config.setupcfg``
"""
from functools import wraps
from typing import Callable, TypeVar, cast

from ..warnings import SetuptoolsDeprecationWarning
from . import setupcfg

Fn = TypeVar("Fn", bound=Callable)

__all__ = ('parse_configuration', 'read_configuration')


def _deprecation_notice(fn: Fn) -> Fn:
    @wraps(fn)
    def _wrapper(*args, **kwargs):
        SetuptoolsDeprecationWarning.emit(
            "Deprecated API usage.",
            f"""
            As setuptools moves its configuration towards `pyproject.toml`,
            `{__name__}.{fn.__name__}` became deprecated.

            For the time being, you can use the `{setupcfg.__name__}` module
            to access a backward compatible API, but this module is provisional
            and might be removed in the future.

            To read project metadata, consider using
            ``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
            For simple scenarios, you can also try parsing the file directly
            with the help of ``configparser``.
            """,
            # due_date not defined yet, because the community still heavily relies on it
            # Warning introduced in 24 Mar 2022
        )
        return fn(*args, **kwargs)

    return cast(Fn, _wrapper)


read_configuration = _deprecation_notice(setupcfg.read_configuration)
parse_configuration = _deprecation_notice(setupcfg.parse_configuration)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/_apply_pyprojecttoml.py0000644000175100001730000003356314467657412024003 0ustar00runnerdocker"""Translation layer between pyproject config and setuptools distribution and
metadata objects.

The distribution and metadata objects are modeled after (an old version of)
core metadata, therefore configs in the format specified for ``pyproject.toml``
need to be processed before being applied.

**PRIVATE MODULE**: API reserved for setuptools internal usage only.
"""
import logging
import os
from collections.abc import Mapping
from email.headerregistry import Address
from functools import partial, reduce
from itertools import chain
from types import MappingProxyType
from typing import (
    TYPE_CHECKING,
    Any,
    Callable,
    Dict,
    List,
    Optional,
    Set,
    Tuple,
    Type,
    Union,
    cast,
)

from ..warnings import SetuptoolsWarning, SetuptoolsDeprecationWarning

if TYPE_CHECKING:
    from setuptools._importlib import metadata  # noqa
    from setuptools.dist import Distribution  # noqa

EMPTY: Mapping = MappingProxyType({})  # Immutable dict-like
_Path = Union[os.PathLike, str]
_DictOrStr = Union[dict, str]
_CorrespFn = Callable[["Distribution", Any, _Path], None]
_Correspondence = Union[str, _CorrespFn]

_logger = logging.getLogger(__name__)


def apply(dist: "Distribution", config: dict, filename: _Path) -> "Distribution":
    """Apply configuration dict read with :func:`read_configuration`"""

    if not config:
        return dist  # short-circuit unrelated pyproject.toml file

    root_dir = os.path.dirname(filename) or "."

    _apply_project_table(dist, config, root_dir)
    _apply_tool_table(dist, config, filename)

    current_directory = os.getcwd()
    os.chdir(root_dir)
    try:
        dist._finalize_requires()
        dist._finalize_license_files()
    finally:
        os.chdir(current_directory)

    return dist


def _apply_project_table(dist: "Distribution", config: dict, root_dir: _Path):
    project_table = config.get("project", {}).copy()
    if not project_table:
        return  # short-circuit

    _handle_missing_dynamic(dist, project_table)
    _unify_entry_points(project_table)

    for field, value in project_table.items():
        norm_key = json_compatible_key(field)
        corresp = PYPROJECT_CORRESPONDENCE.get(norm_key, norm_key)
        if callable(corresp):
            corresp(dist, value, root_dir)
        else:
            _set_config(dist, corresp, value)


def _apply_tool_table(dist: "Distribution", config: dict, filename: _Path):
    tool_table = config.get("tool", {}).get("setuptools", {})
    if not tool_table:
        return  # short-circuit

    for field, value in tool_table.items():
        norm_key = json_compatible_key(field)

        if norm_key in TOOL_TABLE_DEPRECATIONS:
            suggestion, kwargs = TOOL_TABLE_DEPRECATIONS[norm_key]
            msg = f"The parameter `{norm_key}` is deprecated, {suggestion}"
            SetuptoolsDeprecationWarning.emit(
                "Deprecated config", msg, **kwargs  # type: ignore
            )

        norm_key = TOOL_TABLE_RENAMES.get(norm_key, norm_key)
        _set_config(dist, norm_key, value)

    _copy_command_options(config, dist, filename)


def _handle_missing_dynamic(dist: "Distribution", project_table: dict):
    """Be temporarily forgiving with ``dynamic`` fields not listed in ``dynamic``"""
    # TODO: Set fields back to `None` once the feature stabilizes
    dynamic = set(project_table.get("dynamic", []))
    for field, getter in _PREVIOUSLY_DEFINED.items():
        if not (field in project_table or field in dynamic):
            value = getter(dist)
            if value:
                _WouldIgnoreField.emit(field=field, value=value)


def json_compatible_key(key: str) -> str:
    """As defined in :pep:`566#json-compatible-metadata`"""
    return key.lower().replace("-", "_")


def _set_config(dist: "Distribution", field: str, value: Any):
    setter = getattr(dist.metadata, f"set_{field}", None)
    if setter:
        setter(value)
    elif hasattr(dist.metadata, field) or field in SETUPTOOLS_PATCHES:
        setattr(dist.metadata, field, value)
    else:
        setattr(dist, field, value)


_CONTENT_TYPES = {
    ".md": "text/markdown",
    ".rst": "text/x-rst",
    ".txt": "text/plain",
}


def _guess_content_type(file: str) -> Optional[str]:
    _, ext = os.path.splitext(file.lower())
    if not ext:
        return None

    if ext in _CONTENT_TYPES:
        return _CONTENT_TYPES[ext]

    valid = ", ".join(f"{k} ({v})" for k, v in _CONTENT_TYPES.items())
    msg = f"only the following file extensions are recognized: {valid}."
    raise ValueError(f"Undefined content type for {file}, {msg}")


def _long_description(dist: "Distribution", val: _DictOrStr, root_dir: _Path):
    from setuptools.config import expand

    if isinstance(val, str):
        file: Union[str, list] = val
        text = expand.read_files(file, root_dir)
        ctype = _guess_content_type(val)
    else:
        file = val.get("file") or []
        text = val.get("text") or expand.read_files(file, root_dir)
        ctype = val["content-type"]

    _set_config(dist, "long_description", text)

    if ctype:
        _set_config(dist, "long_description_content_type", ctype)

    if file:
        dist._referenced_files.add(cast(str, file))


def _license(dist: "Distribution", val: dict, root_dir: _Path):
    from setuptools.config import expand

    if "file" in val:
        _set_config(dist, "license", expand.read_files([val["file"]], root_dir))
        dist._referenced_files.add(val["file"])
    else:
        _set_config(dist, "license", val["text"])


def _people(dist: "Distribution", val: List[dict], _root_dir: _Path, kind: str):
    field = []
    email_field = []
    for person in val:
        if "name" not in person:
            email_field.append(person["email"])
        elif "email" not in person:
            field.append(person["name"])
        else:
            addr = Address(display_name=person["name"], addr_spec=person["email"])
            email_field.append(str(addr))

    if field:
        _set_config(dist, kind, ", ".join(field))
    if email_field:
        _set_config(dist, f"{kind}_email", ", ".join(email_field))


def _project_urls(dist: "Distribution", val: dict, _root_dir):
    _set_config(dist, "project_urls", val)


def _python_requires(dist: "Distribution", val: dict, _root_dir):
    from setuptools.extern.packaging.specifiers import SpecifierSet

    _set_config(dist, "python_requires", SpecifierSet(val))


def _dependencies(dist: "Distribution", val: list, _root_dir):
    if getattr(dist, "install_requires", []):
        msg = "`install_requires` overwritten in `pyproject.toml` (dependencies)"
        SetuptoolsWarning.emit(msg)
    _set_config(dist, "install_requires", val)


def _optional_dependencies(dist: "Distribution", val: dict, _root_dir):
    existing = getattr(dist, "extras_require", {})
    _set_config(dist, "extras_require", {**existing, **val})


def _unify_entry_points(project_table: dict):
    project = project_table
    entry_points = project.pop("entry-points", project.pop("entry_points", {}))
    renaming = {"scripts": "console_scripts", "gui_scripts": "gui_scripts"}
    for key, value in list(project.items()):  # eager to allow modifications
        norm_key = json_compatible_key(key)
        if norm_key in renaming and value:
            entry_points[renaming[norm_key]] = project.pop(key)

    if entry_points:
        project["entry-points"] = {
            name: [f"{k} = {v}" for k, v in group.items()]
            for name, group in entry_points.items()
        }


def _copy_command_options(pyproject: dict, dist: "Distribution", filename: _Path):
    tool_table = pyproject.get("tool", {})
    cmdclass = tool_table.get("setuptools", {}).get("cmdclass", {})
    valid_options = _valid_command_options(cmdclass)

    cmd_opts = dist.command_options
    for cmd, config in pyproject.get("tool", {}).get("distutils", {}).items():
        cmd = json_compatible_key(cmd)
        valid = valid_options.get(cmd, set())
        cmd_opts.setdefault(cmd, {})
        for key, value in config.items():
            key = json_compatible_key(key)
            cmd_opts[cmd][key] = (str(filename), value)
            if key not in valid:
                # To avoid removing options that are specified dynamically we
                # just log a warn...
                _logger.warning(f"Command option {cmd}.{key} is not defined")


def _valid_command_options(cmdclass: Mapping = EMPTY) -> Dict[str, Set[str]]:
    from .._importlib import metadata
    from setuptools.dist import Distribution

    valid_options = {"global": _normalise_cmd_options(Distribution.global_options)}

    unloaded_entry_points = metadata.entry_points(group='distutils.commands')
    loaded_entry_points = (_load_ep(ep) for ep in unloaded_entry_points)
    entry_points = (ep for ep in loaded_entry_points if ep)
    for cmd, cmd_class in chain(entry_points, cmdclass.items()):
        opts = valid_options.get(cmd, set())
        opts = opts | _normalise_cmd_options(getattr(cmd_class, "user_options", []))
        valid_options[cmd] = opts

    return valid_options


def _load_ep(ep: "metadata.EntryPoint") -> Optional[Tuple[str, Type]]:
    # Ignore all the errors
    try:
        return (ep.name, ep.load())
    except Exception as ex:
        msg = f"{ex.__class__.__name__} while trying to load entry-point {ep.name}"
        _logger.warning(f"{msg}: {ex}")
        return None


def _normalise_cmd_option_key(name: str) -> str:
    return json_compatible_key(name).strip("_=")


def _normalise_cmd_options(desc: List[Tuple[str, Optional[str], str]]) -> Set[str]:
    return {_normalise_cmd_option_key(fancy_option[0]) for fancy_option in desc}


def _get_previous_entrypoints(dist: "Distribution") -> Dict[str, list]:
    ignore = ("console_scripts", "gui_scripts")
    value = getattr(dist, "entry_points", None) or {}
    return {k: v for k, v in value.items() if k not in ignore}


def _get_previous_scripts(dist: "Distribution") -> Optional[list]:
    value = getattr(dist, "entry_points", None) or {}
    return value.get("console_scripts")


def _get_previous_gui_scripts(dist: "Distribution") -> Optional[list]:
    value = getattr(dist, "entry_points", None) or {}
    return value.get("gui_scripts")


def _attrgetter(attr):
    """
    Similar to ``operator.attrgetter`` but returns None if ``attr`` is not found
    >>> from types import SimpleNamespace
    >>> obj = SimpleNamespace(a=42, b=SimpleNamespace(c=13))
    >>> _attrgetter("a")(obj)
    42
    >>> _attrgetter("b.c")(obj)
    13
    >>> _attrgetter("d")(obj) is None
    True
    """
    return partial(reduce, lambda acc, x: getattr(acc, x, None), attr.split("."))


def _some_attrgetter(*items):
    """
    Return the first "truth-y" attribute or None
    >>> from types import SimpleNamespace
    >>> obj = SimpleNamespace(a=42, b=SimpleNamespace(c=13))
    >>> _some_attrgetter("d", "a", "b.c")(obj)
    42
    >>> _some_attrgetter("d", "e", "b.c", "a")(obj)
    13
    >>> _some_attrgetter("d", "e", "f")(obj) is None
    True
    """

    def _acessor(obj):
        values = (_attrgetter(i)(obj) for i in items)
        return next((i for i in values if i is not None), None)

    return _acessor


PYPROJECT_CORRESPONDENCE: Dict[str, _Correspondence] = {
    "readme": _long_description,
    "license": _license,
    "authors": partial(_people, kind="author"),
    "maintainers": partial(_people, kind="maintainer"),
    "urls": _project_urls,
    "dependencies": _dependencies,
    "optional_dependencies": _optional_dependencies,
    "requires_python": _python_requires,
}

TOOL_TABLE_RENAMES = {"script_files": "scripts"}
TOOL_TABLE_DEPRECATIONS = {
    "namespace_packages": (
        "consider using implicit namespaces instead (PEP 420).",
        {"due_date": (2023, 10, 30)},  # warning introduced in May 2022
    )
}

SETUPTOOLS_PATCHES = {
    "long_description_content_type",
    "project_urls",
    "provides_extras",
    "license_file",
    "license_files",
}

_PREVIOUSLY_DEFINED = {
    "name": _attrgetter("metadata.name"),
    "version": _attrgetter("metadata.version"),
    "description": _attrgetter("metadata.description"),
    "readme": _attrgetter("metadata.long_description"),
    "requires-python": _some_attrgetter("python_requires", "metadata.python_requires"),
    "license": _attrgetter("metadata.license"),
    "authors": _some_attrgetter("metadata.author", "metadata.author_email"),
    "maintainers": _some_attrgetter("metadata.maintainer", "metadata.maintainer_email"),
    "keywords": _attrgetter("metadata.keywords"),
    "classifiers": _attrgetter("metadata.classifiers"),
    "urls": _attrgetter("metadata.project_urls"),
    "entry-points": _get_previous_entrypoints,
    "scripts": _get_previous_scripts,
    "gui-scripts": _get_previous_gui_scripts,
    "dependencies": _some_attrgetter("_orig_install_requires", "install_requires"),
    "optional-dependencies": _some_attrgetter("_orig_extras_require", "extras_require"),
}


class _WouldIgnoreField(SetuptoolsDeprecationWarning):
    _SUMMARY = "`{field}` defined outside of `pyproject.toml` would be ignored."

    _DETAILS = """
    ##########################################################################
    # configuration would be ignored/result in error due to `pyproject.toml` #
    ##########################################################################

    The following seems to be defined outside of `pyproject.toml`:

    `{field} = {value!r}`

    According to the spec (see the link below), however, setuptools CANNOT
    consider this value unless `{field}` is listed as `dynamic`.

    https://packaging.python.org/en/latest/specifications/declaring-project-metadata/

    For the time being, `setuptools` will still consider the given value (as a
    **transitional** measure), but please note that future releases of setuptools will
    follow strictly the standard.

    To prevent this warning, you can list `{field}` under `dynamic` or alternatively
    remove the `[project]` table from your file and rely entirely on other means of
    configuration.
    """
    _DUE_DATE = (2023, 10, 30)  # Initially introduced in 27 May 2022
././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.543551
setuptools-68.1.2/setuptools/config/_validate_pyproject/0000755000175100001730000000000014467657444023174 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/_validate_pyproject/__init__.py0000644000175100001730000000201614467657412025277 0ustar00runnerdockerfrom functools import reduce
from typing import Any, Callable, Dict

from . import formats
from .error_reporting import detailed_errors, ValidationError
from .extra_validations import EXTRA_VALIDATIONS
from .fastjsonschema_exceptions import JsonSchemaException, JsonSchemaValueException
from .fastjsonschema_validations import validate as _validate

__all__ = [
    "validate",
    "FORMAT_FUNCTIONS",
    "EXTRA_VALIDATIONS",
    "ValidationError",
    "JsonSchemaException",
    "JsonSchemaValueException",
]


FORMAT_FUNCTIONS: Dict[str, Callable[[str], bool]] = {
    fn.__name__.replace("_", "-"): fn
    for fn in formats.__dict__.values()
    if callable(fn) and not fn.__name__.startswith("_")
}


def validate(data: Any) -> bool:
    """Validate the given ``data`` object using JSON Schema
    This function raises ``ValidationError`` if ``data`` is invalid.
    """
    with detailed_errors():
        _validate(data, custom_formats=FORMAT_FUNCTIONS)
    reduce(lambda acc, fn: fn(acc), EXTRA_VALIDATIONS, data)
    return True
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/_validate_pyproject/error_reporting.py0000644000175100001730000002600214467657412026763 0ustar00runnerdockerimport io
import json
import logging
import os
import re
from contextlib import contextmanager
from textwrap import indent, wrap
from typing import Any, Dict, Iterator, List, Optional, Sequence, Union, cast

from .fastjsonschema_exceptions import JsonSchemaValueException

_logger = logging.getLogger(__name__)

_MESSAGE_REPLACEMENTS = {
    "must be named by propertyName definition": "keys must be named by",
    "one of contains definition": "at least one item that matches",
    " same as const definition:": "",
    "only specified items": "only items matching the definition",
}

_SKIP_DETAILS = (
    "must not be empty",
    "is always invalid",
    "must not be there",
)

_NEED_DETAILS = {"anyOf", "oneOf", "anyOf", "contains", "propertyNames", "not", "items"}

_CAMEL_CASE_SPLITTER = re.compile(r"\W+|([A-Z][^A-Z\W]*)")
_IDENTIFIER = re.compile(r"^[\w_]+$", re.I)

_TOML_JARGON = {
    "object": "table",
    "property": "key",
    "properties": "keys",
    "property names": "keys",
}


class ValidationError(JsonSchemaValueException):
    """Report violations of a given JSON schema.

    This class extends :exc:`~fastjsonschema.JsonSchemaValueException`
    by adding the following properties:

    - ``summary``: an improved version of the ``JsonSchemaValueException`` error message
      with only the necessary information)

    - ``details``: more contextual information about the error like the failing schema
      itself and the value that violates the schema.

    Depending on the level of the verbosity of the ``logging`` configuration
    the exception message will be only ``summary`` (default) or a combination of
    ``summary`` and ``details`` (when the logging level is set to :obj:`logging.DEBUG`).
    """

    summary = ""
    details = ""
    _original_message = ""

    @classmethod
    def _from_jsonschema(cls, ex: JsonSchemaValueException):
        formatter = _ErrorFormatting(ex)
        obj = cls(str(formatter), ex.value, formatter.name, ex.definition, ex.rule)
        debug_code = os.getenv("JSONSCHEMA_DEBUG_CODE_GENERATION", "false").lower()
        if debug_code != "false":  # pragma: no cover
            obj.__cause__, obj.__traceback__ = ex.__cause__, ex.__traceback__
        obj._original_message = ex.message
        obj.summary = formatter.summary
        obj.details = formatter.details
        return obj


@contextmanager
def detailed_errors():
    try:
        yield
    except JsonSchemaValueException as ex:
        raise ValidationError._from_jsonschema(ex) from None


class _ErrorFormatting:
    def __init__(self, ex: JsonSchemaValueException):
        self.ex = ex
        self.name = f"`{self._simplify_name(ex.name)}`"
        self._original_message = self.ex.message.replace(ex.name, self.name)
        self._summary = ""
        self._details = ""

    def __str__(self) -> str:
        if _logger.getEffectiveLevel() <= logging.DEBUG and self.details:
            return f"{self.summary}\n\n{self.details}"

        return self.summary

    @property
    def summary(self) -> str:
        if not self._summary:
            self._summary = self._expand_summary()

        return self._summary

    @property
    def details(self) -> str:
        if not self._details:
            self._details = self._expand_details()

        return self._details

    def _simplify_name(self, name):
        x = len("data.")
        return name[x:] if name.startswith("data.") else name

    def _expand_summary(self):
        msg = self._original_message

        for bad, repl in _MESSAGE_REPLACEMENTS.items():
            msg = msg.replace(bad, repl)

        if any(substring in msg for substring in _SKIP_DETAILS):
            return msg

        schema = self.ex.rule_definition
        if self.ex.rule in _NEED_DETAILS and schema:
            summary = _SummaryWriter(_TOML_JARGON)
            return f"{msg}:\n\n{indent(summary(schema), '    ')}"

        return msg

    def _expand_details(self) -> str:
        optional = []
        desc_lines = self.ex.definition.pop("$$description", [])
        desc = self.ex.definition.pop("description", None) or " ".join(desc_lines)
        if desc:
            description = "\n".join(
                wrap(
                    desc,
                    width=80,
                    initial_indent="    ",
                    subsequent_indent="    ",
                    break_long_words=False,
                )
            )
            optional.append(f"DESCRIPTION:\n{description}")
        schema = json.dumps(self.ex.definition, indent=4)
        value = json.dumps(self.ex.value, indent=4)
        defaults = [
            f"GIVEN VALUE:\n{indent(value, '    ')}",
            f"OFFENDING RULE: {self.ex.rule!r}",
            f"DEFINITION:\n{indent(schema, '    ')}",
        ]
        return "\n\n".join(optional + defaults)


class _SummaryWriter:
    _IGNORE = {"description", "default", "title", "examples"}

    def __init__(self, jargon: Optional[Dict[str, str]] = None):
        self.jargon: Dict[str, str] = jargon or {}
        # Clarify confusing terms
        self._terms = {
            "anyOf": "at least one of the following",
            "oneOf": "exactly one of the following",
            "allOf": "all of the following",
            "not": "(*NOT* the following)",
            "prefixItems": f"{self._jargon('items')} (in order)",
            "items": "items",
            "contains": "contains at least one of",
            "propertyNames": (
                f"non-predefined acceptable {self._jargon('property names')}"
            ),
            "patternProperties": f"{self._jargon('properties')} named via pattern",
            "const": "predefined value",
            "enum": "one of",
        }
        # Attributes that indicate that the definition is easy and can be done
        # inline (e.g. string and number)
        self._guess_inline_defs = [
            "enum",
            "const",
            "maxLength",
            "minLength",
            "pattern",
            "format",
            "minimum",
            "maximum",
            "exclusiveMinimum",
            "exclusiveMaximum",
            "multipleOf",
        ]

    def _jargon(self, term: Union[str, List[str]]) -> Union[str, List[str]]:
        if isinstance(term, list):
            return [self.jargon.get(t, t) for t in term]
        return self.jargon.get(term, term)

    def __call__(
        self,
        schema: Union[dict, List[dict]],
        prefix: str = "",
        *,
        _path: Sequence[str] = (),
    ) -> str:
        if isinstance(schema, list):
            return self._handle_list(schema, prefix, _path)

        filtered = self._filter_unecessary(schema, _path)
        simple = self._handle_simple_dict(filtered, _path)
        if simple:
            return f"{prefix}{simple}"

        child_prefix = self._child_prefix(prefix, "  ")
        item_prefix = self._child_prefix(prefix, "- ")
        indent = len(prefix) * " "
        with io.StringIO() as buffer:
            for i, (key, value) in enumerate(filtered.items()):
                child_path = [*_path, key]
                line_prefix = prefix if i == 0 else indent
                buffer.write(f"{line_prefix}{self._label(child_path)}:")
                # ^  just the first item should receive the complete prefix
                if isinstance(value, dict):
                    filtered = self._filter_unecessary(value, child_path)
                    simple = self._handle_simple_dict(filtered, child_path)
                    buffer.write(
                        f" {simple}"
                        if simple
                        else f"\n{self(value, child_prefix, _path=child_path)}"
                    )
                elif isinstance(value, list) and (
                    key != "type" or self._is_property(child_path)
                ):
                    children = self._handle_list(value, item_prefix, child_path)
                    sep = " " if children.startswith("[") else "\n"
                    buffer.write(f"{sep}{children}")
                else:
                    buffer.write(f" {self._value(value, child_path)}\n")
            return buffer.getvalue()

    def _is_unecessary(self, path: Sequence[str]) -> bool:
        if self._is_property(path) or not path:  # empty path => instruction @ root
            return False
        key = path[-1]
        return any(key.startswith(k) for k in "$_") or key in self._IGNORE

    def _filter_unecessary(self, schema: dict, path: Sequence[str]):
        return {
            key: value
            for key, value in schema.items()
            if not self._is_unecessary([*path, key])
        }

    def _handle_simple_dict(self, value: dict, path: Sequence[str]) -> Optional[str]:
        inline = any(p in value for p in self._guess_inline_defs)
        simple = not any(isinstance(v, (list, dict)) for v in value.values())
        if inline or simple:
            return f"{{{', '.join(self._inline_attrs(value, path))}}}\n"
        return None

    def _handle_list(
        self, schemas: list, prefix: str = "", path: Sequence[str] = ()
    ) -> str:
        if self._is_unecessary(path):
            return ""

        repr_ = repr(schemas)
        if all(not isinstance(e, (dict, list)) for e in schemas) and len(repr_) < 60:
            return f"{repr_}\n"

        item_prefix = self._child_prefix(prefix, "- ")
        return "".join(
            self(v, item_prefix, _path=[*path, f"[{i}]"]) for i, v in enumerate(schemas)
        )

    def _is_property(self, path: Sequence[str]):
        """Check if the given path can correspond to an arbitrarily named property"""
        counter = 0
        for key in path[-2::-1]:
            if key not in {"properties", "patternProperties"}:
                break
            counter += 1

        # If the counter if even, the path correspond to a JSON Schema keyword
        # otherwise it can be any arbitrary string naming a property
        return counter % 2 == 1

    def _label(self, path: Sequence[str]) -> str:
        *parents, key = path
        if not self._is_property(path):
            norm_key = _separate_terms(key)
            return self._terms.get(key) or " ".join(self._jargon(norm_key))

        if parents[-1] == "patternProperties":
            return f"(regex {key!r})"
        return repr(key)  # property name

    def _value(self, value: Any, path: Sequence[str]) -> str:
        if path[-1] == "type" and not self._is_property(path):
            type_ = self._jargon(value)
            return (
                f"[{', '.join(type_)}]" if isinstance(value, list) else cast(str, type_)
            )
        return repr(value)

    def _inline_attrs(self, schema: dict, path: Sequence[str]) -> Iterator[str]:
        for key, value in schema.items():
            child_path = [*path, key]
            yield f"{self._label(child_path)}: {self._value(value, child_path)}"

    def _child_prefix(self, parent_prefix: str, child_prefix: str) -> str:
        return len(parent_prefix) * " " + child_prefix


def _separate_terms(word: str) -> List[str]:
    """
    >>> _separate_terms("FooBar-foo")
    ['foo', 'bar', 'foo']
    """
    return [w.lower() for w in _CAMEL_CASE_SPLITTER.split(word) if w]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/_validate_pyproject/extra_validations.py0000644000175100001730000000220114467657412027254 0ustar00runnerdocker"""The purpose of this module is implement PEP 621 validations that are
difficult to express as a JSON Schema (or that are not supported by the current
JSON Schema library).
"""

from typing import Mapping, TypeVar

from .error_reporting import ValidationError

T = TypeVar("T", bound=Mapping)


class RedefiningStaticFieldAsDynamic(ValidationError):
    """According to PEP 621:

    Build back-ends MUST raise an error if the metadata specifies a field
    statically as well as being listed in dynamic.
    """


def validate_project_dynamic(pyproject: T) -> T:
    project_table = pyproject.get("project", {})
    dynamic = project_table.get("dynamic", [])

    for field in dynamic:
        if field in project_table:
            msg = f"You cannot provide a value for `project.{field}` and "
            msg += "list it under `project.dynamic` at the same time"
            name = f"data.project.{field}"
            value = {field: project_table[field], "...": " # ...", "dynamic": dynamic}
            raise RedefiningStaticFieldAsDynamic(msg, value, name, rule="PEP 621")

    return pyproject


EXTRA_VALIDATIONS = (validate_project_dynamic,)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py0000644000175100001730000000311414467657412031011 0ustar00runnerdockerimport re


SPLIT_RE = re.compile(r'[\.\[\]]+')


class JsonSchemaException(ValueError):
    """
    Base exception of ``fastjsonschema`` library.
    """


class JsonSchemaValueException(JsonSchemaException):
    """
    Exception raised by validation function. Available properties:

     * ``message`` containing human-readable information what is wrong (e.g. ``data.property[index] must be smaller than or equal to 42``),
     * invalid ``value`` (e.g. ``60``),
     * ``name`` of a path in the data structure (e.g. ``data.property[index]``),
     * ``path`` as an array in the data structure (e.g. ``['data', 'property', 'index']``),
     * the whole ``definition`` which the ``value`` has to fulfil (e.g. ``{'type': 'number', 'maximum': 42}``),
     * ``rule`` which the ``value`` is breaking (e.g. ``maximum``)
     * and ``rule_definition`` (e.g. ``42``).

    .. versionchanged:: 2.14.0
        Added all extra properties.
    """

    def __init__(self, message, value=None, name=None, definition=None, rule=None):
        super().__init__(message)
        self.message = message
        self.value = value
        self.name = name
        self.definition = definition
        self.rule = rule

    @property
    def path(self):
        return [item for item in SPLIT_RE.split(self.name) if item != '']

    @property
    def rule_definition(self):
        if not self.rule or not self.definition:
            return None
        return self.definition.get(self.rule)


class JsonSchemaDefinitionException(JsonSchemaException):
    """
    Exception raised by generator of validation function.
    """
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/_validate_pyproject/fastjsonschema_validations.py0000644000175100001730000103073414467657412031156 0ustar00runnerdocker# noqa
# type: ignore
# flake8: noqa
# pylint: skip-file
# mypy: ignore-errors
# yapf: disable
# pylama:skip=1


# *** PLEASE DO NOT MODIFY DIRECTLY: Automatically generated code *** 


VERSION = "2.16.3"
import re
from .fastjsonschema_exceptions import JsonSchemaValueException


REGEX_PATTERNS = {
    '^.*$': re.compile('^.*$'),
    '.+': re.compile('.+'),
    '^.+$': re.compile('^.+$'),
    'idn-email_re_pattern': re.compile('^[^@]+@[^@]+\\.[^@]+\\Z')
}

NoneType = type(None)

def validate(data, custom_formats={}, name_prefix=None):
    validate_https___packaging_python_org_en_latest_specifications_declaring_build_dependencies(data, custom_formats, (name_prefix or "data") + "")
    return data

def validate_https___packaging_python_org_en_latest_specifications_declaring_build_dependencies(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-build-dependencies/', 'title': 'Data structure for ``pyproject.toml`` files', '$$description': ['File format containing build-time configurations for the Python ecosystem. ', ':pep:`517` initially defined a build-system independent format for source trees', 'which was complemented by :pep:`518` to provide a way of specifying dependencies ', 'for building Python projects.', 'Please notice the ``project`` table (as initially defined in  :pep:`621`) is not included', 'in this schema and should be considered separately.'], 'type': 'object', 'additionalProperties': False, 'properties': {'build-system': {'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-project-metadata/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}}, 'required': ['name'], 'additionalProperties': False, 'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, 'tool': {'type': 'object', 'properties': {'distutils': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://docs.python.org/3/install/', 'title': '``tool.distutils`` table', '$$description': ['Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` scripts via `distutils configuration files', '`_.', '``tool.distutils`` subtables could be used with the same purpose', '(NOT CURRENTLY IMPLEMENTED).'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, 'setuptools': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://setuptools.pypa.io/en/latest/references/keywords.html', 'title': '``tool.setuptools`` table', '$$description': ['Please notice for the time being the ``setuptools`` project does not specify', 'a way of configuring builds via ``pyproject.toml``.', 'Therefore this schema should be taken just as a *"thought experiment"* on how', 'this *might be done*, by following the principles established in', '`ini2toml `_.', 'It considers only ``setuptools`` `parameters', '`_', 'that can currently be configured via ``setup.cfg`` and are not covered by :pep:`621`', 'but intentionally excludes ``dependency_links`` and ``setup_requires``.', 'NOTE: ``scripts`` was renamed to ``script-files`` to avoid confusion with', 'entry-point based scripts (defined in :pep:`621`).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'description': 'Whether the project can be safely installed and run from a zip file.', 'type': 'boolean'}, 'script-files': {'description': 'Legacy way of defining scripts (entry-points are preferred).', 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$ref': '#/definitions/package-name'}}, {'$ref': '#/definitions/find-directive'}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$ref': '#/definitions/package-name'}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'data-files': {'$$description': ['**DEPRECATED**: dict-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', "Please notice this don't work with wheels. See `data files support", '`_'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['PROVISIONAL: List of glob patterns for all license files being distributed.', '(might become standard with PEP 639).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'$ref': '#/definitions/attr-directive'}, {'$ref': '#/definitions/file-directive'}]}, 'classifiers': {'$ref': '#/definitions/file-directive'}, 'description': {'$ref': '#/definitions/file-directive'}, 'dependencies': {'$ref': '#/definitions/file-directive'}, 'entry-points': {'$ref': '#/definitions/file-directive'}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$ref': '#/definitions/file-directive'}}}, 'readme': {'anyOf': [{'$ref': '#/definitions/file-directive'}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}}}}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-project-metadata/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}}, 'required': ['name'], 'additionalProperties': False, 'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_keys = set(data.keys())
        if "build-system" in data_keys:
            data_keys.remove("build-system")
            data__buildsystem = data["build-system"]
            if not isinstance(data__buildsystem, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system must be object", value=data__buildsystem, name="" + (name_prefix or "data") + ".build-system", definition={'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, rule='type')
            data__buildsystem_is_dict = isinstance(data__buildsystem, dict)
            if data__buildsystem_is_dict:
                data__buildsystem_len = len(data__buildsystem)
                if not all(prop in data__buildsystem for prop in ['requires']):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system must contain ['requires'] properties", value=data__buildsystem, name="" + (name_prefix or "data") + ".build-system", definition={'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, rule='required')
                data__buildsystem_keys = set(data__buildsystem.keys())
                if "requires" in data__buildsystem_keys:
                    data__buildsystem_keys.remove("requires")
                    data__buildsystem__requires = data__buildsystem["requires"]
                    if not isinstance(data__buildsystem__requires, (list, tuple)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.requires must be array", value=data__buildsystem__requires, name="" + (name_prefix or "data") + ".build-system.requires", definition={'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, rule='type')
                    data__buildsystem__requires_is_list = isinstance(data__buildsystem__requires, (list, tuple))
                    if data__buildsystem__requires_is_list:
                        data__buildsystem__requires_len = len(data__buildsystem__requires)
                        for data__buildsystem__requires_x, data__buildsystem__requires_item in enumerate(data__buildsystem__requires):
                            if not isinstance(data__buildsystem__requires_item, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.requires[{data__buildsystem__requires_x}]".format(**locals()) + " must be string", value=data__buildsystem__requires_item, name="" + (name_prefix or "data") + ".build-system.requires[{data__buildsystem__requires_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                if "build-backend" in data__buildsystem_keys:
                    data__buildsystem_keys.remove("build-backend")
                    data__buildsystem__buildbackend = data__buildsystem["build-backend"]
                    if not isinstance(data__buildsystem__buildbackend, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.build-backend must be string", value=data__buildsystem__buildbackend, name="" + (name_prefix or "data") + ".build-system.build-backend", definition={'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, rule='type')
                    if isinstance(data__buildsystem__buildbackend, str):
                        if not custom_formats["pep517-backend-reference"](data__buildsystem__buildbackend):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.build-backend must be pep517-backend-reference", value=data__buildsystem__buildbackend, name="" + (name_prefix or "data") + ".build-system.build-backend", definition={'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, rule='format')
                if "backend-path" in data__buildsystem_keys:
                    data__buildsystem_keys.remove("backend-path")
                    data__buildsystem__backendpath = data__buildsystem["backend-path"]
                    if not isinstance(data__buildsystem__backendpath, (list, tuple)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.backend-path must be array", value=data__buildsystem__backendpath, name="" + (name_prefix or "data") + ".build-system.backend-path", definition={'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}, rule='type')
                    data__buildsystem__backendpath_is_list = isinstance(data__buildsystem__backendpath, (list, tuple))
                    if data__buildsystem__backendpath_is_list:
                        data__buildsystem__backendpath_len = len(data__buildsystem__backendpath)
                        for data__buildsystem__backendpath_x, data__buildsystem__backendpath_item in enumerate(data__buildsystem__backendpath):
                            if not isinstance(data__buildsystem__backendpath_item, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system.backend-path[{data__buildsystem__backendpath_x}]".format(**locals()) + " must be string", value=data__buildsystem__backendpath_item, name="" + (name_prefix or "data") + ".build-system.backend-path[{data__buildsystem__backendpath_x}]".format(**locals()) + "", definition={'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}, rule='type')
                if data__buildsystem_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".build-system must not contain "+str(data__buildsystem_keys)+" properties", value=data__buildsystem, name="" + (name_prefix or "data") + ".build-system", definition={'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, rule='additionalProperties')
        if "project" in data_keys:
            data_keys.remove("project")
            data__project = data["project"]
            validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata(data__project, custom_formats, (name_prefix or "data") + ".project")
        if "tool" in data_keys:
            data_keys.remove("tool")
            data__tool = data["tool"]
            if not isinstance(data__tool, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".tool must be object", value=data__tool, name="" + (name_prefix or "data") + ".tool", definition={'type': 'object', 'properties': {'distutils': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://docs.python.org/3/install/', 'title': '``tool.distutils`` table', '$$description': ['Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` scripts via `distutils configuration files', '`_.', '``tool.distutils`` subtables could be used with the same purpose', '(NOT CURRENTLY IMPLEMENTED).'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, 'setuptools': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://setuptools.pypa.io/en/latest/references/keywords.html', 'title': '``tool.setuptools`` table', '$$description': ['Please notice for the time being the ``setuptools`` project does not specify', 'a way of configuring builds via ``pyproject.toml``.', 'Therefore this schema should be taken just as a *"thought experiment"* on how', 'this *might be done*, by following the principles established in', '`ini2toml `_.', 'It considers only ``setuptools`` `parameters', '`_', 'that can currently be configured via ``setup.cfg`` and are not covered by :pep:`621`', 'but intentionally excludes ``dependency_links`` and ``setup_requires``.', 'NOTE: ``scripts`` was renamed to ``script-files`` to avoid confusion with', 'entry-point based scripts (defined in :pep:`621`).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'description': 'Whether the project can be safely installed and run from a zip file.', 'type': 'boolean'}, 'script-files': {'description': 'Legacy way of defining scripts (entry-points are preferred).', 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$ref': '#/definitions/package-name'}}, {'$ref': '#/definitions/find-directive'}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$ref': '#/definitions/package-name'}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'data-files': {'$$description': ['**DEPRECATED**: dict-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', "Please notice this don't work with wheels. See `data files support", '`_'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['PROVISIONAL: List of glob patterns for all license files being distributed.', '(might become standard with PEP 639).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'$ref': '#/definitions/attr-directive'}, {'$ref': '#/definitions/file-directive'}]}, 'classifiers': {'$ref': '#/definitions/file-directive'}, 'description': {'$ref': '#/definitions/file-directive'}, 'dependencies': {'$ref': '#/definitions/file-directive'}, 'entry-points': {'$ref': '#/definitions/file-directive'}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$ref': '#/definitions/file-directive'}}}, 'readme': {'anyOf': [{'$ref': '#/definitions/file-directive'}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}}}, rule='type')
            data__tool_is_dict = isinstance(data__tool, dict)
            if data__tool_is_dict:
                data__tool_keys = set(data__tool.keys())
                if "distutils" in data__tool_keys:
                    data__tool_keys.remove("distutils")
                    data__tool__distutils = data__tool["distutils"]
                    validate_https___docs_python_org_3_install(data__tool__distutils, custom_formats, (name_prefix or "data") + ".tool.distutils")
                if "setuptools" in data__tool_keys:
                    data__tool_keys.remove("setuptools")
                    data__tool__setuptools = data__tool["setuptools"]
                    validate_https___setuptools_pypa_io_en_latest_references_keywords_html(data__tool__setuptools, custom_formats, (name_prefix or "data") + ".tool.setuptools")
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-build-dependencies/', 'title': 'Data structure for ``pyproject.toml`` files', '$$description': ['File format containing build-time configurations for the Python ecosystem. ', ':pep:`517` initially defined a build-system independent format for source trees', 'which was complemented by :pep:`518` to provide a way of specifying dependencies ', 'for building Python projects.', 'Please notice the ``project`` table (as initially defined in  :pep:`621`) is not included', 'in this schema and should be considered separately.'], 'type': 'object', 'additionalProperties': False, 'properties': {'build-system': {'type': 'object', 'description': 'Table used to store build-related data', 'additionalProperties': False, 'properties': {'requires': {'type': 'array', '$$description': ['List of dependencies in the :pep:`508` format required to execute the build', 'system. Please notice that the resulting dependency graph', '**MUST NOT contain cycles**'], 'items': {'type': 'string'}}, 'build-backend': {'type': 'string', 'description': 'Python object that will be used to perform the build according to :pep:`517`', 'format': 'pep517-backend-reference'}, 'backend-path': {'type': 'array', '$$description': ['List of directories to be prepended to ``sys.path`` when loading the', 'back-end, and running its hooks'], 'items': {'type': 'string', '$comment': 'Should be a path (TODO: enforce it with format?)'}}}, 'required': ['requires']}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-project-metadata/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}}, 'required': ['name'], 'additionalProperties': False, 'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, 'tool': {'type': 'object', 'properties': {'distutils': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://docs.python.org/3/install/', 'title': '``tool.distutils`` table', '$$description': ['Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` scripts via `distutils configuration files', '`_.', '``tool.distutils`` subtables could be used with the same purpose', '(NOT CURRENTLY IMPLEMENTED).'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, 'setuptools': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://setuptools.pypa.io/en/latest/references/keywords.html', 'title': '``tool.setuptools`` table', '$$description': ['Please notice for the time being the ``setuptools`` project does not specify', 'a way of configuring builds via ``pyproject.toml``.', 'Therefore this schema should be taken just as a *"thought experiment"* on how', 'this *might be done*, by following the principles established in', '`ini2toml `_.', 'It considers only ``setuptools`` `parameters', '`_', 'that can currently be configured via ``setup.cfg`` and are not covered by :pep:`621`', 'but intentionally excludes ``dependency_links`` and ``setup_requires``.', 'NOTE: ``scripts`` was renamed to ``script-files`` to avoid confusion with', 'entry-point based scripts (defined in :pep:`621`).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'description': 'Whether the project can be safely installed and run from a zip file.', 'type': 'boolean'}, 'script-files': {'description': 'Legacy way of defining scripts (entry-points are preferred).', 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$ref': '#/definitions/package-name'}}, {'$ref': '#/definitions/find-directive'}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$ref': '#/definitions/package-name'}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'data-files': {'$$description': ['**DEPRECATED**: dict-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', "Please notice this don't work with wheels. See `data files support", '`_'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['PROVISIONAL: List of glob patterns for all license files being distributed.', '(might become standard with PEP 639).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'$ref': '#/definitions/attr-directive'}, {'$ref': '#/definitions/file-directive'}]}, 'classifiers': {'$ref': '#/definitions/file-directive'}, 'description': {'$ref': '#/definitions/file-directive'}, 'dependencies': {'$ref': '#/definitions/file-directive'}, 'entry-points': {'$ref': '#/definitions/file-directive'}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$ref': '#/definitions/file-directive'}}}, 'readme': {'anyOf': [{'$ref': '#/definitions/file-directive'}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}}}}, 'project': {'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-project-metadata/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'authors': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$ref': '#/definitions/author'}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create command-line wrappers for the given', '`entry points `_.']}, 'gui-scripts': {'$ref': '#/definitions/entry-point-group', '$$description': ['Instruct the installer to create GUI wrappers for the given', '`entry points `_.', 'The difference between ``scripts`` and ``gui-scripts`` is only relevant in', 'Windows.']}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$ref': '#/definitions/entry-point-group'}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$ref': '#/definitions/dependency'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$ref': '#/definitions/dependency'}}}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}}, 'required': ['name'], 'additionalProperties': False, 'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='additionalProperties')
    return data

def validate_https___setuptools_pypa_io_en_latest_references_keywords_html(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://setuptools.pypa.io/en/latest/references/keywords.html', 'title': '``tool.setuptools`` table', '$$description': ['Please notice for the time being the ``setuptools`` project does not specify', 'a way of configuring builds via ``pyproject.toml``.', 'Therefore this schema should be taken just as a *"thought experiment"* on how', 'this *might be done*, by following the principles established in', '`ini2toml `_.', 'It considers only ``setuptools`` `parameters', '`_', 'that can currently be configured via ``setup.cfg`` and are not covered by :pep:`621`', 'but intentionally excludes ``dependency_links`` and ``setup_requires``.', 'NOTE: ``scripts`` was renamed to ``script-files`` to avoid confusion with', 'entry-point based scripts (defined in :pep:`621`).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'description': 'Whether the project can be safely installed and run from a zip file.', 'type': 'boolean'}, 'script-files': {'description': 'Legacy way of defining scripts (entry-points are preferred).', 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}}, {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'data-files': {'$$description': ['**DEPRECATED**: dict-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', "Please notice this don't work with wheels. See `data files support", '`_'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['PROVISIONAL: List of glob patterns for all license files being distributed.', '(might become standard with PEP 639).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}}}, 'readme': {'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_keys = set(data.keys())
        if "platforms" in data_keys:
            data_keys.remove("platforms")
            data__platforms = data["platforms"]
            if not isinstance(data__platforms, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".platforms must be array", value=data__platforms, name="" + (name_prefix or "data") + ".platforms", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
            data__platforms_is_list = isinstance(data__platforms, (list, tuple))
            if data__platforms_is_list:
                data__platforms_len = len(data__platforms)
                for data__platforms_x, data__platforms_item in enumerate(data__platforms):
                    if not isinstance(data__platforms_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".platforms[{data__platforms_x}]".format(**locals()) + " must be string", value=data__platforms_item, name="" + (name_prefix or "data") + ".platforms[{data__platforms_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
        if "provides" in data_keys:
            data_keys.remove("provides")
            data__provides = data["provides"]
            if not isinstance(data__provides, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".provides must be array", value=data__provides, name="" + (name_prefix or "data") + ".provides", definition={'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, rule='type')
            data__provides_is_list = isinstance(data__provides, (list, tuple))
            if data__provides_is_list:
                data__provides_len = len(data__provides)
                for data__provides_x, data__provides_item in enumerate(data__provides):
                    if not isinstance(data__provides_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + " must be string", value=data__provides_item, name="" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='type')
                    if isinstance(data__provides_item, str):
                        if not custom_formats["pep508-identifier"](data__provides_item):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + " must be pep508-identifier", value=data__provides_item, name="" + (name_prefix or "data") + ".provides[{data__provides_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='format')
        if "obsoletes" in data_keys:
            data_keys.remove("obsoletes")
            data__obsoletes = data["obsoletes"]
            if not isinstance(data__obsoletes, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".obsoletes must be array", value=data__obsoletes, name="" + (name_prefix or "data") + ".obsoletes", definition={'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, rule='type')
            data__obsoletes_is_list = isinstance(data__obsoletes, (list, tuple))
            if data__obsoletes_is_list:
                data__obsoletes_len = len(data__obsoletes)
                for data__obsoletes_x, data__obsoletes_item in enumerate(data__obsoletes):
                    if not isinstance(data__obsoletes_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + " must be string", value=data__obsoletes_item, name="" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='type')
                    if isinstance(data__obsoletes_item, str):
                        if not custom_formats["pep508-identifier"](data__obsoletes_item):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + " must be pep508-identifier", value=data__obsoletes_item, name="" + (name_prefix or "data") + ".obsoletes[{data__obsoletes_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'pep508-identifier'}, rule='format')
        if "zip-safe" in data_keys:
            data_keys.remove("zip-safe")
            data__zipsafe = data["zip-safe"]
            if not isinstance(data__zipsafe, (bool)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".zip-safe must be boolean", value=data__zipsafe, name="" + (name_prefix or "data") + ".zip-safe", definition={'description': 'Whether the project can be safely installed and run from a zip file.', 'type': 'boolean'}, rule='type')
        if "script-files" in data_keys:
            data_keys.remove("script-files")
            data__scriptfiles = data["script-files"]
            if not isinstance(data__scriptfiles, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".script-files must be array", value=data__scriptfiles, name="" + (name_prefix or "data") + ".script-files", definition={'description': 'Legacy way of defining scripts (entry-points are preferred).', 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, rule='type')
            data__scriptfiles_is_list = isinstance(data__scriptfiles, (list, tuple))
            if data__scriptfiles_is_list:
                data__scriptfiles_len = len(data__scriptfiles)
                for data__scriptfiles_x, data__scriptfiles_item in enumerate(data__scriptfiles):
                    if not isinstance(data__scriptfiles_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".script-files[{data__scriptfiles_x}]".format(**locals()) + " must be string", value=data__scriptfiles_item, name="" + (name_prefix or "data") + ".script-files[{data__scriptfiles_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
        if "eager-resources" in data_keys:
            data_keys.remove("eager-resources")
            data__eagerresources = data["eager-resources"]
            if not isinstance(data__eagerresources, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".eager-resources must be array", value=data__eagerresources, name="" + (name_prefix or "data") + ".eager-resources", definition={'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.'], 'type': 'array', 'items': {'type': 'string'}}, rule='type')
            data__eagerresources_is_list = isinstance(data__eagerresources, (list, tuple))
            if data__eagerresources_is_list:
                data__eagerresources_len = len(data__eagerresources)
                for data__eagerresources_x, data__eagerresources_item in enumerate(data__eagerresources):
                    if not isinstance(data__eagerresources_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".eager-resources[{data__eagerresources_x}]".format(**locals()) + " must be string", value=data__eagerresources_item, name="" + (name_prefix or "data") + ".eager-resources[{data__eagerresources_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
        if "packages" in data_keys:
            data_keys.remove("packages")
            data__packages = data["packages"]
            data__packages_one_of_count1 = 0
            if data__packages_one_of_count1 < 2:
                try:
                    if not isinstance(data__packages, (list, tuple)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".packages must be array", value=data__packages, name="" + (name_prefix or "data") + ".packages", definition={'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}}, rule='type')
                    data__packages_is_list = isinstance(data__packages, (list, tuple))
                    if data__packages_is_list:
                        data__packages_len = len(data__packages)
                        for data__packages_x, data__packages_item in enumerate(data__packages):
                            validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_package_name(data__packages_item, custom_formats, (name_prefix or "data") + ".packages[{data__packages_x}]".format(**locals()))
                    data__packages_one_of_count1 += 1
                except JsonSchemaValueException: pass
            if data__packages_one_of_count1 < 2:
                try:
                    validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_find_directive(data__packages, custom_formats, (name_prefix or "data") + ".packages")
                    data__packages_one_of_count1 += 1
                except JsonSchemaValueException: pass
            if data__packages_one_of_count1 != 1:
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".packages must be valid exactly by one definition" + (" (" + str(data__packages_one_of_count1) + " matches found)"), value=data__packages, name="" + (name_prefix or "data") + ".packages", definition={'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}}, {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}]}, rule='oneOf')
        if "package-dir" in data_keys:
            data_keys.remove("package-dir")
            data__packagedir = data["package-dir"]
            if not isinstance(data__packagedir, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be object", value=data__packagedir, name="" + (name_prefix or "data") + ".package-dir", definition={'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, rule='type')
            data__packagedir_is_dict = isinstance(data__packagedir, dict)
            if data__packagedir_is_dict:
                data__packagedir_keys = set(data__packagedir.keys())
                for data__packagedir_key, data__packagedir_val in data__packagedir.items():
                    if REGEX_PATTERNS['^.*$'].search(data__packagedir_key):
                        if data__packagedir_key in data__packagedir_keys:
                            data__packagedir_keys.remove(data__packagedir_key)
                        if not isinstance(data__packagedir_val, (str)):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir.{data__packagedir_key}".format(**locals()) + " must be string", value=data__packagedir_val, name="" + (name_prefix or "data") + ".package-dir.{data__packagedir_key}".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                if data__packagedir_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must not contain "+str(data__packagedir_keys)+" properties", value=data__packagedir, name="" + (name_prefix or "data") + ".package-dir", definition={'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, rule='additionalProperties')
                data__packagedir_len = len(data__packagedir)
                if data__packagedir_len != 0:
                    data__packagedir_property_names = True
                    for data__packagedir_key in data__packagedir:
                        try:
                            data__packagedir_key_one_of_count2 = 0
                            if data__packagedir_key_one_of_count2 < 2:
                                try:
                                    if data__packagedir_key != "":
                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be same as const definition: ", value=data__packagedir_key, name="" + (name_prefix or "data") + ".package-dir", definition={'const': ''}, rule='const')
                                    data__packagedir_key_one_of_count2 += 1
                                except JsonSchemaValueException: pass
                            if data__packagedir_key_one_of_count2 < 2:
                                try:
                                    validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_package_name(data__packagedir_key, custom_formats, (name_prefix or "data") + ".package-dir")
                                    data__packagedir_key_one_of_count2 += 1
                                except JsonSchemaValueException: pass
                            if data__packagedir_key_one_of_count2 != 1:
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be valid exactly by one definition" + (" (" + str(data__packagedir_key_one_of_count2) + " matches found)"), value=data__packagedir_key, name="" + (name_prefix or "data") + ".package-dir", definition={'oneOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}]}, rule='oneOf')
                        except JsonSchemaValueException:
                            data__packagedir_property_names = False
                    if not data__packagedir_property_names:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-dir must be named by propertyName definition", value=data__packagedir, name="" + (name_prefix or "data") + ".package-dir", definition={'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, rule='propertyNames')
        if "package-data" in data_keys:
            data_keys.remove("package-data")
            data__packagedata = data["package-data"]
            if not isinstance(data__packagedata, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be object", value=data__packagedata, name="" + (name_prefix or "data") + ".package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='type')
            data__packagedata_is_dict = isinstance(data__packagedata, dict)
            if data__packagedata_is_dict:
                data__packagedata_keys = set(data__packagedata.keys())
                for data__packagedata_key, data__packagedata_val in data__packagedata.items():
                    if REGEX_PATTERNS['^.*$'].search(data__packagedata_key):
                        if data__packagedata_key in data__packagedata_keys:
                            data__packagedata_keys.remove(data__packagedata_key)
                        if not isinstance(data__packagedata_val, (list, tuple)):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data.{data__packagedata_key}".format(**locals()) + " must be array", value=data__packagedata_val, name="" + (name_prefix or "data") + ".package-data.{data__packagedata_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
                        data__packagedata_val_is_list = isinstance(data__packagedata_val, (list, tuple))
                        if data__packagedata_val_is_list:
                            data__packagedata_val_len = len(data__packagedata_val)
                            for data__packagedata_val_x, data__packagedata_val_item in enumerate(data__packagedata_val):
                                if not isinstance(data__packagedata_val_item, (str)):
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data.{data__packagedata_key}[{data__packagedata_val_x}]".format(**locals()) + " must be string", value=data__packagedata_val_item, name="" + (name_prefix or "data") + ".package-data.{data__packagedata_key}[{data__packagedata_val_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                if data__packagedata_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must not contain "+str(data__packagedata_keys)+" properties", value=data__packagedata, name="" + (name_prefix or "data") + ".package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='additionalProperties')
                data__packagedata_len = len(data__packagedata)
                if data__packagedata_len != 0:
                    data__packagedata_property_names = True
                    for data__packagedata_key in data__packagedata:
                        try:
                            data__packagedata_key_one_of_count3 = 0
                            if data__packagedata_key_one_of_count3 < 2:
                                try:
                                    if isinstance(data__packagedata_key, str):
                                        if not custom_formats["python-module-name"](data__packagedata_key):
                                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be python-module-name", value=data__packagedata_key, name="" + (name_prefix or "data") + ".package-data", definition={'format': 'python-module-name'}, rule='format')
                                    data__packagedata_key_one_of_count3 += 1
                                except JsonSchemaValueException: pass
                            if data__packagedata_key_one_of_count3 < 2:
                                try:
                                    if data__packagedata_key != "*":
                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be same as const definition: *", value=data__packagedata_key, name="" + (name_prefix or "data") + ".package-data", definition={'const': '*'}, rule='const')
                                    data__packagedata_key_one_of_count3 += 1
                                except JsonSchemaValueException: pass
                            if data__packagedata_key_one_of_count3 != 1:
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be valid exactly by one definition" + (" (" + str(data__packagedata_key_one_of_count3) + " matches found)"), value=data__packagedata_key, name="" + (name_prefix or "data") + ".package-data", definition={'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, rule='oneOf')
                        except JsonSchemaValueException:
                            data__packagedata_property_names = False
                    if not data__packagedata_property_names:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".package-data must be named by propertyName definition", value=data__packagedata, name="" + (name_prefix or "data") + ".package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='propertyNames')
        if "include-package-data" in data_keys:
            data_keys.remove("include-package-data")
            data__includepackagedata = data["include-package-data"]
            if not isinstance(data__includepackagedata, (bool)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".include-package-data must be boolean", value=data__includepackagedata, name="" + (name_prefix or "data") + ".include-package-data", definition={'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, rule='type')
        if "exclude-package-data" in data_keys:
            data_keys.remove("exclude-package-data")
            data__excludepackagedata = data["exclude-package-data"]
            if not isinstance(data__excludepackagedata, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be object", value=data__excludepackagedata, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='type')
            data__excludepackagedata_is_dict = isinstance(data__excludepackagedata, dict)
            if data__excludepackagedata_is_dict:
                data__excludepackagedata_keys = set(data__excludepackagedata.keys())
                for data__excludepackagedata_key, data__excludepackagedata_val in data__excludepackagedata.items():
                    if REGEX_PATTERNS['^.*$'].search(data__excludepackagedata_key):
                        if data__excludepackagedata_key in data__excludepackagedata_keys:
                            data__excludepackagedata_keys.remove(data__excludepackagedata_key)
                        if not isinstance(data__excludepackagedata_val, (list, tuple)):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}".format(**locals()) + " must be array", value=data__excludepackagedata_val, name="" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
                        data__excludepackagedata_val_is_list = isinstance(data__excludepackagedata_val, (list, tuple))
                        if data__excludepackagedata_val_is_list:
                            data__excludepackagedata_val_len = len(data__excludepackagedata_val)
                            for data__excludepackagedata_val_x, data__excludepackagedata_val_item in enumerate(data__excludepackagedata_val):
                                if not isinstance(data__excludepackagedata_val_item, (str)):
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}[{data__excludepackagedata_val_x}]".format(**locals()) + " must be string", value=data__excludepackagedata_val_item, name="" + (name_prefix or "data") + ".exclude-package-data.{data__excludepackagedata_key}[{data__excludepackagedata_val_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                if data__excludepackagedata_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must not contain "+str(data__excludepackagedata_keys)+" properties", value=data__excludepackagedata, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='additionalProperties')
                data__excludepackagedata_len = len(data__excludepackagedata)
                if data__excludepackagedata_len != 0:
                    data__excludepackagedata_property_names = True
                    for data__excludepackagedata_key in data__excludepackagedata:
                        try:
                            data__excludepackagedata_key_one_of_count4 = 0
                            if data__excludepackagedata_key_one_of_count4 < 2:
                                try:
                                    if isinstance(data__excludepackagedata_key, str):
                                        if not custom_formats["python-module-name"](data__excludepackagedata_key):
                                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be python-module-name", value=data__excludepackagedata_key, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'format': 'python-module-name'}, rule='format')
                                    data__excludepackagedata_key_one_of_count4 += 1
                                except JsonSchemaValueException: pass
                            if data__excludepackagedata_key_one_of_count4 < 2:
                                try:
                                    if data__excludepackagedata_key != "*":
                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be same as const definition: *", value=data__excludepackagedata_key, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'const': '*'}, rule='const')
                                    data__excludepackagedata_key_one_of_count4 += 1
                                except JsonSchemaValueException: pass
                            if data__excludepackagedata_key_one_of_count4 != 1:
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be valid exactly by one definition" + (" (" + str(data__excludepackagedata_key_one_of_count4) + " matches found)"), value=data__excludepackagedata_key, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, rule='oneOf')
                        except JsonSchemaValueException:
                            data__excludepackagedata_property_names = False
                    if not data__excludepackagedata_property_names:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".exclude-package-data must be named by propertyName definition", value=data__excludepackagedata, name="" + (name_prefix or "data") + ".exclude-package-data", definition={'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='propertyNames')
        if "namespace-packages" in data_keys:
            data_keys.remove("namespace-packages")
            data__namespacepackages = data["namespace-packages"]
            if not isinstance(data__namespacepackages, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".namespace-packages must be array", value=data__namespacepackages, name="" + (name_prefix or "data") + ".namespace-packages", definition={'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html'}, rule='type')
            data__namespacepackages_is_list = isinstance(data__namespacepackages, (list, tuple))
            if data__namespacepackages_is_list:
                data__namespacepackages_len = len(data__namespacepackages)
                for data__namespacepackages_x, data__namespacepackages_item in enumerate(data__namespacepackages):
                    if not isinstance(data__namespacepackages_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + " must be string", value=data__namespacepackages_item, name="" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name'}, rule='type')
                    if isinstance(data__namespacepackages_item, str):
                        if not custom_formats["python-module-name"](data__namespacepackages_item):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + " must be python-module-name", value=data__namespacepackages_item, name="" + (name_prefix or "data") + ".namespace-packages[{data__namespacepackages_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name'}, rule='format')
        if "py-modules" in data_keys:
            data_keys.remove("py-modules")
            data__pymodules = data["py-modules"]
            if not isinstance(data__pymodules, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".py-modules must be array", value=data__pymodules, name="" + (name_prefix or "data") + ".py-modules", definition={'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, rule='type')
            data__pymodules_is_list = isinstance(data__pymodules, (list, tuple))
            if data__pymodules_is_list:
                data__pymodules_len = len(data__pymodules)
                for data__pymodules_x, data__pymodules_item in enumerate(data__pymodules):
                    if not isinstance(data__pymodules_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + " must be string", value=data__pymodules_item, name="" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name'}, rule='type')
                    if isinstance(data__pymodules_item, str):
                        if not custom_formats["python-module-name"](data__pymodules_item):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + " must be python-module-name", value=data__pymodules_item, name="" + (name_prefix or "data") + ".py-modules[{data__pymodules_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'python-module-name'}, rule='format')
        if "data-files" in data_keys:
            data_keys.remove("data-files")
            data__datafiles = data["data-files"]
            if not isinstance(data__datafiles, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".data-files must be object", value=data__datafiles, name="" + (name_prefix or "data") + ".data-files", definition={'$$description': ['**DEPRECATED**: dict-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', "Please notice this don't work with wheels. See `data files support", '`_'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, rule='type')
            data__datafiles_is_dict = isinstance(data__datafiles, dict)
            if data__datafiles_is_dict:
                data__datafiles_keys = set(data__datafiles.keys())
                for data__datafiles_key, data__datafiles_val in data__datafiles.items():
                    if REGEX_PATTERNS['^.*$'].search(data__datafiles_key):
                        if data__datafiles_key in data__datafiles_keys:
                            data__datafiles_keys.remove(data__datafiles_key)
                        if not isinstance(data__datafiles_val, (list, tuple)):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".data-files.{data__datafiles_key}".format(**locals()) + " must be array", value=data__datafiles_val, name="" + (name_prefix or "data") + ".data-files.{data__datafiles_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
                        data__datafiles_val_is_list = isinstance(data__datafiles_val, (list, tuple))
                        if data__datafiles_val_is_list:
                            data__datafiles_val_len = len(data__datafiles_val)
                            for data__datafiles_val_x, data__datafiles_val_item in enumerate(data__datafiles_val):
                                if not isinstance(data__datafiles_val_item, (str)):
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".data-files.{data__datafiles_key}[{data__datafiles_val_x}]".format(**locals()) + " must be string", value=data__datafiles_val_item, name="" + (name_prefix or "data") + ".data-files.{data__datafiles_key}[{data__datafiles_val_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
        if "cmdclass" in data_keys:
            data_keys.remove("cmdclass")
            data__cmdclass = data["cmdclass"]
            if not isinstance(data__cmdclass, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".cmdclass must be object", value=data__cmdclass, name="" + (name_prefix or "data") + ".cmdclass", definition={'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, rule='type')
            data__cmdclass_is_dict = isinstance(data__cmdclass, dict)
            if data__cmdclass_is_dict:
                data__cmdclass_keys = set(data__cmdclass.keys())
                for data__cmdclass_key, data__cmdclass_val in data__cmdclass.items():
                    if REGEX_PATTERNS['^.*$'].search(data__cmdclass_key):
                        if data__cmdclass_key in data__cmdclass_keys:
                            data__cmdclass_keys.remove(data__cmdclass_key)
                        if not isinstance(data__cmdclass_val, (str)):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + " must be string", value=data__cmdclass_val, name="" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'python-qualified-identifier'}, rule='type')
                        if isinstance(data__cmdclass_val, str):
                            if not custom_formats["python-qualified-identifier"](data__cmdclass_val):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + " must be python-qualified-identifier", value=data__cmdclass_val, name="" + (name_prefix or "data") + ".cmdclass.{data__cmdclass_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'python-qualified-identifier'}, rule='format')
        if "license-files" in data_keys:
            data_keys.remove("license-files")
            data__licensefiles = data["license-files"]
            if not isinstance(data__licensefiles, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license-files must be array", value=data__licensefiles, name="" + (name_prefix or "data") + ".license-files", definition={'type': 'array', 'items': {'type': 'string'}, '$$description': ['PROVISIONAL: List of glob patterns for all license files being distributed.', '(might become standard with PEP 639).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, rule='type')
            data__licensefiles_is_list = isinstance(data__licensefiles, (list, tuple))
            if data__licensefiles_is_list:
                data__licensefiles_len = len(data__licensefiles)
                for data__licensefiles_x, data__licensefiles_item in enumerate(data__licensefiles):
                    if not isinstance(data__licensefiles_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".license-files[{data__licensefiles_x}]".format(**locals()) + " must be string", value=data__licensefiles_item, name="" + (name_prefix or "data") + ".license-files[{data__licensefiles_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
        if "dynamic" in data_keys:
            data_keys.remove("dynamic")
            data__dynamic = data["dynamic"]
            if not isinstance(data__dynamic, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must be object", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}}}, 'readme': {'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}}}, rule='type')
            data__dynamic_is_dict = isinstance(data__dynamic, dict)
            if data__dynamic_is_dict:
                data__dynamic_keys = set(data__dynamic.keys())
                if "version" in data__dynamic_keys:
                    data__dynamic_keys.remove("version")
                    data__dynamic__version = data__dynamic["version"]
                    data__dynamic__version_one_of_count5 = 0
                    if data__dynamic__version_one_of_count5 < 2:
                        try:
                            validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_attr_directive(data__dynamic__version, custom_formats, (name_prefix or "data") + ".dynamic.version")
                            data__dynamic__version_one_of_count5 += 1
                        except JsonSchemaValueException: pass
                    if data__dynamic__version_one_of_count5 < 2:
                        try:
                            validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data__dynamic__version, custom_formats, (name_prefix or "data") + ".dynamic.version")
                            data__dynamic__version_one_of_count5 += 1
                        except JsonSchemaValueException: pass
                    if data__dynamic__version_one_of_count5 != 1:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.version must be valid exactly by one definition" + (" (" + str(data__dynamic__version_one_of_count5) + " matches found)"), value=data__dynamic__version, name="" + (name_prefix or "data") + ".dynamic.version", definition={'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, rule='oneOf')
                if "classifiers" in data__dynamic_keys:
                    data__dynamic_keys.remove("classifiers")
                    data__dynamic__classifiers = data__dynamic["classifiers"]
                    validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data__dynamic__classifiers, custom_formats, (name_prefix or "data") + ".dynamic.classifiers")
                if "description" in data__dynamic_keys:
                    data__dynamic_keys.remove("description")
                    data__dynamic__description = data__dynamic["description"]
                    validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data__dynamic__description, custom_formats, (name_prefix or "data") + ".dynamic.description")
                if "dependencies" in data__dynamic_keys:
                    data__dynamic_keys.remove("dependencies")
                    data__dynamic__dependencies = data__dynamic["dependencies"]
                    validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data__dynamic__dependencies, custom_formats, (name_prefix or "data") + ".dynamic.dependencies")
                if "entry-points" in data__dynamic_keys:
                    data__dynamic_keys.remove("entry-points")
                    data__dynamic__entrypoints = data__dynamic["entry-points"]
                    validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data__dynamic__entrypoints, custom_formats, (name_prefix or "data") + ".dynamic.entry-points")
                if "optional-dependencies" in data__dynamic_keys:
                    data__dynamic_keys.remove("optional-dependencies")
                    data__dynamic__optionaldependencies = data__dynamic["optional-dependencies"]
                    if not isinstance(data__dynamic__optionaldependencies, (dict)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must be object", value=data__dynamic__optionaldependencies, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}}}, rule='type')
                    data__dynamic__optionaldependencies_is_dict = isinstance(data__dynamic__optionaldependencies, dict)
                    if data__dynamic__optionaldependencies_is_dict:
                        data__dynamic__optionaldependencies_keys = set(data__dynamic__optionaldependencies.keys())
                        for data__dynamic__optionaldependencies_key, data__dynamic__optionaldependencies_val in data__dynamic__optionaldependencies.items():
                            if REGEX_PATTERNS['.+'].search(data__dynamic__optionaldependencies_key):
                                if data__dynamic__optionaldependencies_key in data__dynamic__optionaldependencies_keys:
                                    data__dynamic__optionaldependencies_keys.remove(data__dynamic__optionaldependencies_key)
                                validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data__dynamic__optionaldependencies_val, custom_formats, (name_prefix or "data") + ".dynamic.optional-dependencies.{data__dynamic__optionaldependencies_key}".format(**locals()))
                        if data__dynamic__optionaldependencies_keys:
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must not contain "+str(data__dynamic__optionaldependencies_keys)+" properties", value=data__dynamic__optionaldependencies, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}}}, rule='additionalProperties')
                        data__dynamic__optionaldependencies_len = len(data__dynamic__optionaldependencies)
                        if data__dynamic__optionaldependencies_len != 0:
                            data__dynamic__optionaldependencies_property_names = True
                            for data__dynamic__optionaldependencies_key in data__dynamic__optionaldependencies:
                                try:
                                    if isinstance(data__dynamic__optionaldependencies_key, str):
                                        if not custom_formats["python-identifier"](data__dynamic__optionaldependencies_key):
                                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must be python-identifier", value=data__dynamic__optionaldependencies_key, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'format': 'python-identifier'}, rule='format')
                                except JsonSchemaValueException:
                                    data__dynamic__optionaldependencies_property_names = False
                            if not data__dynamic__optionaldependencies_property_names:
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.optional-dependencies must be named by propertyName definition", value=data__dynamic__optionaldependencies, name="" + (name_prefix or "data") + ".dynamic.optional-dependencies", definition={'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}}}, rule='propertyNames')
                if "readme" in data__dynamic_keys:
                    data__dynamic_keys.remove("readme")
                    data__dynamic__readme = data__dynamic["readme"]
                    data__dynamic__readme_any_of_count6 = 0
                    if not data__dynamic__readme_any_of_count6:
                        try:
                            validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data__dynamic__readme, custom_formats, (name_prefix or "data") + ".dynamic.readme")
                            data__dynamic__readme_any_of_count6 += 1
                        except JsonSchemaValueException: pass
                    if not data__dynamic__readme_any_of_count6:
                        try:
                            data__dynamic__readme_is_dict = isinstance(data__dynamic__readme, dict)
                            if data__dynamic__readme_is_dict:
                                data__dynamic__readme_keys = set(data__dynamic__readme.keys())
                                if "content-type" in data__dynamic__readme_keys:
                                    data__dynamic__readme_keys.remove("content-type")
                                    data__dynamic__readme__contenttype = data__dynamic__readme["content-type"]
                                    if not isinstance(data__dynamic__readme__contenttype, (str)):
                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme.content-type must be string", value=data__dynamic__readme__contenttype, name="" + (name_prefix or "data") + ".dynamic.readme.content-type", definition={'type': 'string'}, rule='type')
                            data__dynamic__readme_any_of_count6 += 1
                        except JsonSchemaValueException: pass
                    if not data__dynamic__readme_any_of_count6:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme cannot be validated by any definition", value=data__dynamic__readme, name="" + (name_prefix or "data") + ".dynamic.readme", definition={'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}, rule='anyOf')
                    data__dynamic__readme_is_dict = isinstance(data__dynamic__readme, dict)
                    if data__dynamic__readme_is_dict:
                        data__dynamic__readme_len = len(data__dynamic__readme)
                        if not all(prop in data__dynamic__readme for prop in ['file']):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic.readme must contain ['file'] properties", value=data__dynamic__readme, name="" + (name_prefix or "data") + ".dynamic.readme", definition={'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}, rule='required')
                if data__dynamic_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must not contain "+str(data__dynamic_keys)+" properties", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}}}, 'readme': {'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}}}, rule='additionalProperties')
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://setuptools.pypa.io/en/latest/references/keywords.html', 'title': '``tool.setuptools`` table', '$$description': ['Please notice for the time being the ``setuptools`` project does not specify', 'a way of configuring builds via ``pyproject.toml``.', 'Therefore this schema should be taken just as a *"thought experiment"* on how', 'this *might be done*, by following the principles established in', '`ini2toml `_.', 'It considers only ``setuptools`` `parameters', '`_', 'that can currently be configured via ``setup.cfg`` and are not covered by :pep:`621`', 'but intentionally excludes ``dependency_links`` and ``setup_requires``.', 'NOTE: ``scripts`` was renamed to ``script-files`` to avoid confusion with', 'entry-point based scripts (defined in :pep:`621`).'], 'type': 'object', 'additionalProperties': False, 'properties': {'platforms': {'type': 'array', 'items': {'type': 'string'}}, 'provides': {'$$description': ['Package and virtual package names contained within this package', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'obsoletes': {'$$description': ['Packages which this package renders obsolete', '**(not supported by pip)**'], 'type': 'array', 'items': {'type': 'string', 'format': 'pep508-identifier'}}, 'zip-safe': {'description': 'Whether the project can be safely installed and run from a zip file.', 'type': 'boolean'}, 'script-files': {'description': 'Legacy way of defining scripts (entry-points are preferred).', 'type': 'array', 'items': {'type': 'string'}, '$comment': 'TODO: is this field deprecated/should be removed?'}, 'eager-resources': {'$$description': ['Resources that should be extracted together, if any of them is needed,', 'or if any C extensions included in the project are imported.'], 'type': 'array', 'items': {'type': 'string'}}, 'packages': {'$$description': ['Packages that should be included in the distribution.', 'It can be given either as a list of package identifiers', 'or as a ``dict``-like structure with a single key ``find``', 'which corresponds to a dynamic call to', '``setuptools.config.expand.find_packages`` function.', 'The ``find`` key is associated with a nested ``dict``-like structure that can', 'contain ``where``, ``include``, ``exclude`` and ``namespaces`` keys,', 'mimicking the keyword arguments of the associated function.'], 'oneOf': [{'title': 'Array of Python package identifiers', 'type': 'array', 'items': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}}, {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}]}, 'package-dir': {'$$description': [':class:`dict`-like structure mapping from package names to directories where their', 'code can be found.', 'The empty string (as key) means that all packages are contained inside', 'the given directory will be included in the distribution.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'const': ''}, {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}]}, 'patternProperties': {'^.*$': {'type': 'string'}}}, 'package-data': {'$$description': ['Mapping from package names to lists of glob patterns.', 'Usually this option is not needed when using ``include-package-data = true``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'include-package-data': {'$$description': ['Automatically include any data files inside the package directories', 'that are specified by ``MANIFEST.in``', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'boolean'}, 'exclude-package-data': {'$$description': ['Mapping from package names to lists of glob patterns that should be excluded', 'For more information on how to include data files, check ``setuptools`` `docs', '`_.'], 'type': 'object', 'additionalProperties': False, 'propertyNames': {'oneOf': [{'format': 'python-module-name'}, {'const': '*'}]}, 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'namespace-packages': {'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'https://setuptools.pypa.io/en/latest/userguide/package_discovery.html'}, 'py-modules': {'description': 'Modules that setuptools will manipulate', 'type': 'array', 'items': {'type': 'string', 'format': 'python-module-name'}, '$comment': 'TODO: clarify the relationship with ``packages``'}, 'data-files': {'$$description': ['**DEPRECATED**: dict-like structure where each key represents a directory and', 'the value is a list of glob patterns that should be installed in them.', "Please notice this don't work with wheels. See `data files support", '`_'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'array', 'items': {'type': 'string'}}}}, 'cmdclass': {'$$description': ['Mapping of distutils-style command names to ``setuptools.Command`` subclasses', 'which in turn should be represented by strings with a qualified class name', '(i.e., "dotted" form with module), e.g.::\n\n', '    cmdclass = {mycmd = "pkg.subpkg.module.CommandClass"}\n\n', 'The command class should be a directly defined at the top-level of the', 'containing module (no class nesting).'], 'type': 'object', 'patternProperties': {'^.*$': {'type': 'string', 'format': 'python-qualified-identifier'}}}, 'license-files': {'type': 'array', 'items': {'type': 'string'}, '$$description': ['PROVISIONAL: List of glob patterns for all license files being distributed.', '(might become standard with PEP 639).', "By default: ``['LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*']``"], '$comment': 'TODO: revise if PEP 639 is accepted. Probably ``project.license-files``?'}, 'dynamic': {'type': 'object', 'description': 'Instructions for loading :pep:`621`-related metadata dynamically', 'additionalProperties': False, 'properties': {'version': {'$$description': ['A version dynamically loaded via either the ``attr:`` or ``file:``', 'directives. Please make sure the given file or attribute respects :pep:`440`.'], 'oneOf': [{'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}]}, 'classifiers': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'description': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'dependencies': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'entry-points': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'optional-dependencies': {'type': 'object', 'propertyNames': {'format': 'python-identifier'}, 'additionalProperties': False, 'patternProperties': {'.+': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}}}, 'readme': {'anyOf': [{'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, {'properties': {'content-type': {'type': 'string'}}}], 'required': ['file']}}}}, 'definitions': {'package-name': {'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}, 'file-directive': {'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, 'attr-directive': {'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, 'find-directive': {'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}}}, rule='additionalProperties')
    return data

def validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_file_directive(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_len = len(data)
        if not all(prop in data for prop in ['file']):
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain ['file'] properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, rule='required')
        data_keys = set(data.keys())
        if "file" in data_keys:
            data_keys.remove("file")
            data__file = data["file"]
            data__file_one_of_count7 = 0
            if data__file_one_of_count7 < 2:
                try:
                    if not isinstance(data__file, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".file must be string", value=data__file, name="" + (name_prefix or "data") + ".file", definition={'type': 'string'}, rule='type')
                    data__file_one_of_count7 += 1
                except JsonSchemaValueException: pass
            if data__file_one_of_count7 < 2:
                try:
                    if not isinstance(data__file, (list, tuple)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".file must be array", value=data__file, name="" + (name_prefix or "data") + ".file", definition={'type': 'array', 'items': {'type': 'string'}}, rule='type')
                    data__file_is_list = isinstance(data__file, (list, tuple))
                    if data__file_is_list:
                        data__file_len = len(data__file)
                        for data__file_x, data__file_item in enumerate(data__file):
                            if not isinstance(data__file_item, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".file[{data__file_x}]".format(**locals()) + " must be string", value=data__file_item, name="" + (name_prefix or "data") + ".file[{data__file_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                    data__file_one_of_count7 += 1
                except JsonSchemaValueException: pass
            if data__file_one_of_count7 != 1:
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".file must be valid exactly by one definition" + (" (" + str(data__file_one_of_count7) + " matches found)"), value=data__file, name="" + (name_prefix or "data") + ".file", definition={'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}, rule='oneOf')
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/file-directive', 'title': "'file:' directive", 'description': 'Value is read from a file (or list of files and then concatenated)', 'type': 'object', 'additionalProperties': False, 'properties': {'file': {'oneOf': [{'type': 'string'}, {'type': 'array', 'items': {'type': 'string'}}]}}, 'required': ['file']}, rule='additionalProperties')
    return data

def validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_attr_directive(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_len = len(data)
        if not all(prop in data for prop in ['attr']):
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain ['attr'] properties", value=data, name="" + (name_prefix or "data") + "", definition={'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, rule='required')
        data_keys = set(data.keys())
        if "attr" in data_keys:
            data_keys.remove("attr")
            data__attr = data["attr"]
            if not isinstance(data__attr, (str)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".attr must be string", value=data__attr, name="" + (name_prefix or "data") + ".attr", definition={'type': 'string'}, rule='type')
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'title': "'attr:' directive", '$id': '#/definitions/attr-directive', '$$description': ['Value is read from a module attribute. Supports callables and iterables;', 'unsupported types are cast via ``str()``'], 'type': 'object', 'additionalProperties': False, 'properties': {'attr': {'type': 'string'}}, 'required': ['attr']}, rule='additionalProperties')
    return data

def validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_find_directive(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_keys = set(data.keys())
        if "find" in data_keys:
            data_keys.remove("find")
            data__find = data["find"]
            if not isinstance(data__find, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find must be object", value=data__find, name="" + (name_prefix or "data") + ".find", definition={'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}, rule='type')
            data__find_is_dict = isinstance(data__find, dict)
            if data__find_is_dict:
                data__find_keys = set(data__find.keys())
                if "where" in data__find_keys:
                    data__find_keys.remove("where")
                    data__find__where = data__find["where"]
                    if not isinstance(data__find__where, (list, tuple)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.where must be array", value=data__find__where, name="" + (name_prefix or "data") + ".find.where", definition={'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, rule='type')
                    data__find__where_is_list = isinstance(data__find__where, (list, tuple))
                    if data__find__where_is_list:
                        data__find__where_len = len(data__find__where)
                        for data__find__where_x, data__find__where_item in enumerate(data__find__where):
                            if not isinstance(data__find__where_item, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.where[{data__find__where_x}]".format(**locals()) + " must be string", value=data__find__where_item, name="" + (name_prefix or "data") + ".find.where[{data__find__where_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                if "exclude" in data__find_keys:
                    data__find_keys.remove("exclude")
                    data__find__exclude = data__find["exclude"]
                    if not isinstance(data__find__exclude, (list, tuple)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.exclude must be array", value=data__find__exclude, name="" + (name_prefix or "data") + ".find.exclude", definition={'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, rule='type')
                    data__find__exclude_is_list = isinstance(data__find__exclude, (list, tuple))
                    if data__find__exclude_is_list:
                        data__find__exclude_len = len(data__find__exclude)
                        for data__find__exclude_x, data__find__exclude_item in enumerate(data__find__exclude):
                            if not isinstance(data__find__exclude_item, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.exclude[{data__find__exclude_x}]".format(**locals()) + " must be string", value=data__find__exclude_item, name="" + (name_prefix or "data") + ".find.exclude[{data__find__exclude_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                if "include" in data__find_keys:
                    data__find_keys.remove("include")
                    data__find__include = data__find["include"]
                    if not isinstance(data__find__include, (list, tuple)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.include must be array", value=data__find__include, name="" + (name_prefix or "data") + ".find.include", definition={'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, rule='type')
                    data__find__include_is_list = isinstance(data__find__include, (list, tuple))
                    if data__find__include_is_list:
                        data__find__include_len = len(data__find__include)
                        for data__find__include_x, data__find__include_item in enumerate(data__find__include):
                            if not isinstance(data__find__include_item, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.include[{data__find__include_x}]".format(**locals()) + " must be string", value=data__find__include_item, name="" + (name_prefix or "data") + ".find.include[{data__find__include_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
                if "namespaces" in data__find_keys:
                    data__find_keys.remove("namespaces")
                    data__find__namespaces = data__find["namespaces"]
                    if not isinstance(data__find__namespaces, (bool)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".find.namespaces must be boolean", value=data__find__namespaces, name="" + (name_prefix or "data") + ".find.namespaces", definition={'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}, rule='type')
                if data__find_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".find must not contain "+str(data__find_keys)+" properties", value=data__find, name="" + (name_prefix or "data") + ".find", definition={'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}, rule='additionalProperties')
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/find-directive', 'title': "'find:' directive", 'type': 'object', 'additionalProperties': False, 'properties': {'find': {'type': 'object', '$$description': ['Dynamic `package discovery', '`_.'], 'additionalProperties': False, 'properties': {'where': {'description': 'Directories to be searched for packages (Unix-style relative path)', 'type': 'array', 'items': {'type': 'string'}}, 'exclude': {'type': 'array', '$$description': ['Exclude packages that match the values listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'include': {'type': 'array', '$$description': ['Restrict the found packages to just the ones listed in this field.', "Can container shell-style wildcards (e.g. ``'pkg.*'``)"], 'items': {'type': 'string'}}, 'namespaces': {'type': 'boolean', '$$description': ['When ``True``, directories without a ``__init__.py`` file will also', 'be scanned for :pep:`420`-style implicit namespaces']}}}}}, rule='additionalProperties')
    return data

def validate_https___setuptools_pypa_io_en_latest_references_keywords_html__definitions_package_name(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (str)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be string", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}, rule='type')
    data_any_of_count8 = 0
    if not data_any_of_count8:
        try:
            if isinstance(data, str):
                if not custom_formats["python-module-name"](data):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must be python-module-name", value=data, name="" + (name_prefix or "data") + "", definition={'format': 'python-module-name'}, rule='format')
            data_any_of_count8 += 1
        except JsonSchemaValueException: pass
    if not data_any_of_count8:
        try:
            if isinstance(data, str):
                if not custom_formats["pep561-stub-name"](data):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must be pep561-stub-name", value=data, name="" + (name_prefix or "data") + "", definition={'format': 'pep561-stub-name'}, rule='format')
            data_any_of_count8 += 1
        except JsonSchemaValueException: pass
    if not data_any_of_count8:
        raise JsonSchemaValueException("" + (name_prefix or "data") + " cannot be validated by any definition", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/package-name', 'title': 'Valid package name', 'description': 'Valid package name (importable or PEP 561).', 'type': 'string', 'anyOf': [{'format': 'python-module-name'}, {'format': 'pep561-stub-name'}]}, rule='anyOf')
    return data

def validate_https___docs_python_org_3_install(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://docs.python.org/3/install/', 'title': '``tool.distutils`` table', '$$description': ['Originally, ``distutils`` allowed developers to configure arguments for', '``setup.py`` scripts via `distutils configuration files', '`_.', '``tool.distutils`` subtables could be used with the same purpose', '(NOT CURRENTLY IMPLEMENTED).'], 'type': 'object', 'properties': {'global': {'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}}, 'patternProperties': {'.+': {'type': 'object'}}, '$comment': 'TODO: Is there a practical way of making this schema more specific?'}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_keys = set(data.keys())
        if "global" in data_keys:
            data_keys.remove("global")
            data__global = data["global"]
            if not isinstance(data__global, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".global must be object", value=data__global, name="" + (name_prefix or "data") + ".global", definition={'type': 'object', 'description': 'Global options applied to all ``distutils`` commands'}, rule='type')
        for data_key, data_val in data.items():
            if REGEX_PATTERNS['.+'].search(data_key):
                if data_key in data_keys:
                    data_keys.remove(data_key)
                if not isinstance(data_val, (dict)):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".{data_key}".format(**locals()) + " must be object", value=data_val, name="" + (name_prefix or "data") + ".{data_key}".format(**locals()) + "", definition={'type': 'object'}, rule='type')
    return data

def validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-project-metadata/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'authors': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'gui-scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}}, 'required': ['name'], 'additionalProperties': False, 'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_len = len(data)
        if not all(prop in data for prop in ['name']):
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain ['name'] properties", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-project-metadata/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'authors': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'gui-scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}}, 'required': ['name'], 'additionalProperties': False, 'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, rule='required')
        data_keys = set(data.keys())
        if "name" in data_keys:
            data_keys.remove("name")
            data__name = data["name"]
            if not isinstance(data__name, (str)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be string", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, rule='type')
            if isinstance(data__name, str):
                if not custom_formats["pep508-identifier"](data__name):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be pep508-identifier", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, rule='format')
        if "version" in data_keys:
            data_keys.remove("version")
            data__version = data["version"]
            if not isinstance(data__version, (str)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".version must be string", value=data__version, name="" + (name_prefix or "data") + ".version", definition={'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, rule='type')
            if isinstance(data__version, str):
                if not custom_formats["pep440"](data__version):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".version must be pep440", value=data__version, name="" + (name_prefix or "data") + ".version", definition={'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, rule='format')
        if "description" in data_keys:
            data_keys.remove("description")
            data__description = data["description"]
            if not isinstance(data__description, (str)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".description must be string", value=data__description, name="" + (name_prefix or "data") + ".description", definition={'type': 'string', '$$description': ['The `summary description of the project', '`_']}, rule='type')
        if "readme" in data_keys:
            data_keys.remove("readme")
            data__readme = data["readme"]
            data__readme_one_of_count9 = 0
            if data__readme_one_of_count9 < 2:
                try:
                    if not isinstance(data__readme, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must be string", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, rule='type')
                    data__readme_one_of_count9 += 1
                except JsonSchemaValueException: pass
            if data__readme_one_of_count9 < 2:
                try:
                    if not isinstance(data__readme, (dict)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must be object", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}, rule='type')
                    data__readme_any_of_count10 = 0
                    if not data__readme_any_of_count10:
                        try:
                            data__readme_is_dict = isinstance(data__readme, dict)
                            if data__readme_is_dict:
                                data__readme_len = len(data__readme)
                                if not all(prop in data__readme for prop in ['file']):
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must contain ['file'] properties", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, rule='required')
                                data__readme_keys = set(data__readme.keys())
                                if "file" in data__readme_keys:
                                    data__readme_keys.remove("file")
                                    data__readme__file = data__readme["file"]
                                    if not isinstance(data__readme__file, (str)):
                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme.file must be string", value=data__readme__file, name="" + (name_prefix or "data") + ".readme.file", definition={'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}, rule='type')
                            data__readme_any_of_count10 += 1
                        except JsonSchemaValueException: pass
                    if not data__readme_any_of_count10:
                        try:
                            data__readme_is_dict = isinstance(data__readme, dict)
                            if data__readme_is_dict:
                                data__readme_len = len(data__readme)
                                if not all(prop in data__readme for prop in ['text']):
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must contain ['text'] properties", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}, rule='required')
                                data__readme_keys = set(data__readme.keys())
                                if "text" in data__readme_keys:
                                    data__readme_keys.remove("text")
                                    data__readme__text = data__readme["text"]
                                    if not isinstance(data__readme__text, (str)):
                                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme.text must be string", value=data__readme__text, name="" + (name_prefix or "data") + ".readme.text", definition={'type': 'string', 'description': 'Full text describing the project.'}, rule='type')
                            data__readme_any_of_count10 += 1
                        except JsonSchemaValueException: pass
                    if not data__readme_any_of_count10:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme cannot be validated by any definition", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, rule='anyOf')
                    data__readme_is_dict = isinstance(data__readme, dict)
                    if data__readme_is_dict:
                        data__readme_len = len(data__readme)
                        if not all(prop in data__readme for prop in ['content-type']):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must contain ['content-type'] properties", value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}, rule='required')
                        data__readme_keys = set(data__readme.keys())
                        if "content-type" in data__readme_keys:
                            data__readme_keys.remove("content-type")
                            data__readme__contenttype = data__readme["content-type"]
                            if not isinstance(data__readme__contenttype, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme.content-type must be string", value=data__readme__contenttype, name="" + (name_prefix or "data") + ".readme.content-type", definition={'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}, rule='type')
                    data__readme_one_of_count9 += 1
                except JsonSchemaValueException: pass
            if data__readme_one_of_count9 != 1:
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".readme must be valid exactly by one definition" + (" (" + str(data__readme_one_of_count9) + " matches found)"), value=data__readme, name="" + (name_prefix or "data") + ".readme", definition={'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, rule='oneOf')
        if "requires-python" in data_keys:
            data_keys.remove("requires-python")
            data__requirespython = data["requires-python"]
            if not isinstance(data__requirespython, (str)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".requires-python must be string", value=data__requirespython, name="" + (name_prefix or "data") + ".requires-python", definition={'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, rule='type')
            if isinstance(data__requirespython, str):
                if not custom_formats["pep508-versionspec"](data__requirespython):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".requires-python must be pep508-versionspec", value=data__requirespython, name="" + (name_prefix or "data") + ".requires-python", definition={'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, rule='format')
        if "license" in data_keys:
            data_keys.remove("license")
            data__license = data["license"]
            data__license_one_of_count11 = 0
            if data__license_one_of_count11 < 2:
                try:
                    data__license_is_dict = isinstance(data__license, dict)
                    if data__license_is_dict:
                        data__license_len = len(data__license)
                        if not all(prop in data__license for prop in ['file']):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must contain ['file'] properties", value=data__license, name="" + (name_prefix or "data") + ".license", definition={'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, rule='required')
                        data__license_keys = set(data__license.keys())
                        if "file" in data__license_keys:
                            data__license_keys.remove("file")
                            data__license__file = data__license["file"]
                            if not isinstance(data__license__file, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license.file must be string", value=data__license__file, name="" + (name_prefix or "data") + ".license.file", definition={'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}, rule='type')
                    data__license_one_of_count11 += 1
                except JsonSchemaValueException: pass
            if data__license_one_of_count11 < 2:
                try:
                    data__license_is_dict = isinstance(data__license, dict)
                    if data__license_is_dict:
                        data__license_len = len(data__license)
                        if not all(prop in data__license for prop in ['text']):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must contain ['text'] properties", value=data__license, name="" + (name_prefix or "data") + ".license", definition={'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}, rule='required')
                        data__license_keys = set(data__license.keys())
                        if "text" in data__license_keys:
                            data__license_keys.remove("text")
                            data__license__text = data__license["text"]
                            if not isinstance(data__license__text, (str)):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license.text must be string", value=data__license__text, name="" + (name_prefix or "data") + ".license.text", definition={'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}, rule='type')
                    data__license_one_of_count11 += 1
                except JsonSchemaValueException: pass
            if data__license_one_of_count11 != 1:
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".license must be valid exactly by one definition" + (" (" + str(data__license_one_of_count11) + " matches found)"), value=data__license, name="" + (name_prefix or "data") + ".license", definition={'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, rule='oneOf')
        if "authors" in data_keys:
            data_keys.remove("authors")
            data__authors = data["authors"]
            if not isinstance(data__authors, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".authors must be array", value=data__authors, name="" + (name_prefix or "data") + ".authors", definition={'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, rule='type')
            data__authors_is_list = isinstance(data__authors, (list, tuple))
            if data__authors_is_list:
                data__authors_len = len(data__authors)
                for data__authors_x, data__authors_item in enumerate(data__authors):
                    validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_author(data__authors_item, custom_formats, (name_prefix or "data") + ".authors[{data__authors_x}]".format(**locals()))
        if "maintainers" in data_keys:
            data_keys.remove("maintainers")
            data__maintainers = data["maintainers"]
            if not isinstance(data__maintainers, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".maintainers must be array", value=data__maintainers, name="" + (name_prefix or "data") + ".maintainers", definition={'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, rule='type')
            data__maintainers_is_list = isinstance(data__maintainers, (list, tuple))
            if data__maintainers_is_list:
                data__maintainers_len = len(data__maintainers)
                for data__maintainers_x, data__maintainers_item in enumerate(data__maintainers):
                    validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_author(data__maintainers_item, custom_formats, (name_prefix or "data") + ".maintainers[{data__maintainers_x}]".format(**locals()))
        if "keywords" in data_keys:
            data_keys.remove("keywords")
            data__keywords = data["keywords"]
            if not isinstance(data__keywords, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".keywords must be array", value=data__keywords, name="" + (name_prefix or "data") + ".keywords", definition={'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, rule='type')
            data__keywords_is_list = isinstance(data__keywords, (list, tuple))
            if data__keywords_is_list:
                data__keywords_len = len(data__keywords)
                for data__keywords_x, data__keywords_item in enumerate(data__keywords):
                    if not isinstance(data__keywords_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".keywords[{data__keywords_x}]".format(**locals()) + " must be string", value=data__keywords_item, name="" + (name_prefix or "data") + ".keywords[{data__keywords_x}]".format(**locals()) + "", definition={'type': 'string'}, rule='type')
        if "classifiers" in data_keys:
            data_keys.remove("classifiers")
            data__classifiers = data["classifiers"]
            if not isinstance(data__classifiers, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".classifiers must be array", value=data__classifiers, name="" + (name_prefix or "data") + ".classifiers", definition={'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, rule='type')
            data__classifiers_is_list = isinstance(data__classifiers, (list, tuple))
            if data__classifiers_is_list:
                data__classifiers_len = len(data__classifiers)
                for data__classifiers_x, data__classifiers_item in enumerate(data__classifiers):
                    if not isinstance(data__classifiers_item, (str)):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + " must be string", value=data__classifiers_item, name="" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, rule='type')
                    if isinstance(data__classifiers_item, str):
                        if not custom_formats["trove-classifier"](data__classifiers_item):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + " must be trove-classifier", value=data__classifiers_item, name="" + (name_prefix or "data") + ".classifiers[{data__classifiers_x}]".format(**locals()) + "", definition={'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, rule='format')
        if "urls" in data_keys:
            data_keys.remove("urls")
            data__urls = data["urls"]
            if not isinstance(data__urls, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls must be object", value=data__urls, name="" + (name_prefix or "data") + ".urls", definition={'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, rule='type')
            data__urls_is_dict = isinstance(data__urls, dict)
            if data__urls_is_dict:
                data__urls_keys = set(data__urls.keys())
                for data__urls_key, data__urls_val in data__urls.items():
                    if REGEX_PATTERNS['^.+$'].search(data__urls_key):
                        if data__urls_key in data__urls_keys:
                            data__urls_keys.remove(data__urls_key)
                        if not isinstance(data__urls_val, (str)):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + " must be string", value=data__urls_val, name="" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'url'}, rule='type')
                        if isinstance(data__urls_val, str):
                            if not custom_formats["url"](data__urls_val):
                                raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + " must be url", value=data__urls_val, name="" + (name_prefix or "data") + ".urls.{data__urls_key}".format(**locals()) + "", definition={'type': 'string', 'format': 'url'}, rule='format')
                if data__urls_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".urls must not contain "+str(data__urls_keys)+" properties", value=data__urls, name="" + (name_prefix or "data") + ".urls", definition={'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, rule='additionalProperties')
        if "scripts" in data_keys:
            data_keys.remove("scripts")
            data__scripts = data["scripts"]
            validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_entry_point_group(data__scripts, custom_formats, (name_prefix or "data") + ".scripts")
        if "gui-scripts" in data_keys:
            data_keys.remove("gui-scripts")
            data__guiscripts = data["gui-scripts"]
            validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_entry_point_group(data__guiscripts, custom_formats, (name_prefix or "data") + ".gui-scripts")
        if "entry-points" in data_keys:
            data_keys.remove("entry-points")
            data__entrypoints = data["entry-points"]
            data__entrypoints_is_dict = isinstance(data__entrypoints, dict)
            if data__entrypoints_is_dict:
                data__entrypoints_keys = set(data__entrypoints.keys())
                for data__entrypoints_key, data__entrypoints_val in data__entrypoints.items():
                    if REGEX_PATTERNS['^.+$'].search(data__entrypoints_key):
                        if data__entrypoints_key in data__entrypoints_keys:
                            data__entrypoints_keys.remove(data__entrypoints_key)
                        validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_entry_point_group(data__entrypoints_val, custom_formats, (name_prefix or "data") + ".entry-points.{data__entrypoints_key}".format(**locals()))
                if data__entrypoints_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".entry-points must not contain "+str(data__entrypoints_keys)+" properties", value=data__entrypoints, name="" + (name_prefix or "data") + ".entry-points", definition={'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, rule='additionalProperties')
                data__entrypoints_len = len(data__entrypoints)
                if data__entrypoints_len != 0:
                    data__entrypoints_property_names = True
                    for data__entrypoints_key in data__entrypoints:
                        try:
                            if isinstance(data__entrypoints_key, str):
                                if not custom_formats["python-entrypoint-group"](data__entrypoints_key):
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".entry-points must be python-entrypoint-group", value=data__entrypoints_key, name="" + (name_prefix or "data") + ".entry-points", definition={'format': 'python-entrypoint-group'}, rule='format')
                        except JsonSchemaValueException:
                            data__entrypoints_property_names = False
                    if not data__entrypoints_property_names:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".entry-points must be named by propertyName definition", value=data__entrypoints, name="" + (name_prefix or "data") + ".entry-points", definition={'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, rule='propertyNames')
        if "dependencies" in data_keys:
            data_keys.remove("dependencies")
            data__dependencies = data["dependencies"]
            if not isinstance(data__dependencies, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dependencies must be array", value=data__dependencies, name="" + (name_prefix or "data") + ".dependencies", definition={'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, rule='type')
            data__dependencies_is_list = isinstance(data__dependencies, (list, tuple))
            if data__dependencies_is_list:
                data__dependencies_len = len(data__dependencies)
                for data__dependencies_x, data__dependencies_item in enumerate(data__dependencies):
                    validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_dependency(data__dependencies_item, custom_formats, (name_prefix or "data") + ".dependencies[{data__dependencies_x}]".format(**locals()))
        if "optional-dependencies" in data_keys:
            data_keys.remove("optional-dependencies")
            data__optionaldependencies = data["optional-dependencies"]
            if not isinstance(data__optionaldependencies, (dict)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must be object", value=data__optionaldependencies, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='type')
            data__optionaldependencies_is_dict = isinstance(data__optionaldependencies, dict)
            if data__optionaldependencies_is_dict:
                data__optionaldependencies_keys = set(data__optionaldependencies.keys())
                for data__optionaldependencies_key, data__optionaldependencies_val in data__optionaldependencies.items():
                    if REGEX_PATTERNS['^.+$'].search(data__optionaldependencies_key):
                        if data__optionaldependencies_key in data__optionaldependencies_keys:
                            data__optionaldependencies_keys.remove(data__optionaldependencies_key)
                        if not isinstance(data__optionaldependencies_val, (list, tuple)):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies.{data__optionaldependencies_key}".format(**locals()) + " must be array", value=data__optionaldependencies_val, name="" + (name_prefix or "data") + ".optional-dependencies.{data__optionaldependencies_key}".format(**locals()) + "", definition={'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, rule='type')
                        data__optionaldependencies_val_is_list = isinstance(data__optionaldependencies_val, (list, tuple))
                        if data__optionaldependencies_val_is_list:
                            data__optionaldependencies_val_len = len(data__optionaldependencies_val)
                            for data__optionaldependencies_val_x, data__optionaldependencies_val_item in enumerate(data__optionaldependencies_val):
                                validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_dependency(data__optionaldependencies_val_item, custom_formats, (name_prefix or "data") + ".optional-dependencies.{data__optionaldependencies_key}[{data__optionaldependencies_val_x}]".format(**locals()))
                if data__optionaldependencies_keys:
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must not contain "+str(data__optionaldependencies_keys)+" properties", value=data__optionaldependencies, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='additionalProperties')
                data__optionaldependencies_len = len(data__optionaldependencies)
                if data__optionaldependencies_len != 0:
                    data__optionaldependencies_property_names = True
                    for data__optionaldependencies_key in data__optionaldependencies:
                        try:
                            if isinstance(data__optionaldependencies_key, str):
                                if not custom_formats["pep508-identifier"](data__optionaldependencies_key):
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must be pep508-identifier", value=data__optionaldependencies_key, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'format': 'pep508-identifier'}, rule='format')
                        except JsonSchemaValueException:
                            data__optionaldependencies_property_names = False
                    if not data__optionaldependencies_property_names:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".optional-dependencies must be named by propertyName definition", value=data__optionaldependencies, name="" + (name_prefix or "data") + ".optional-dependencies", definition={'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, rule='propertyNames')
        if "dynamic" in data_keys:
            data_keys.remove("dynamic")
            data__dynamic = data["dynamic"]
            if not isinstance(data__dynamic, (list, tuple)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must be array", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}, rule='type')
            data__dynamic_is_list = isinstance(data__dynamic, (list, tuple))
            if data__dynamic_is_list:
                data__dynamic_len = len(data__dynamic)
                for data__dynamic_x, data__dynamic_item in enumerate(data__dynamic):
                    if data__dynamic_item not in ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']:
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic[{data__dynamic_x}]".format(**locals()) + " must be one of ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']", value=data__dynamic_item, name="" + (name_prefix or "data") + ".dynamic[{data__dynamic_x}]".format(**locals()) + "", definition={'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}, rule='enum')
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$schema': 'http://json-schema.org/draft-07/schema', '$id': 'https://packaging.python.org/en/latest/specifications/declaring-project-metadata/', 'title': 'Package metadata stored in the ``project`` table', '$$description': ['Data structure for the **project** table inside ``pyproject.toml``', '(as initially defined in :pep:`621`)'], 'type': 'object', 'properties': {'name': {'type': 'string', 'description': 'The name (primary identifier) of the project. MUST be statically defined.', 'format': 'pep508-identifier'}, 'version': {'type': 'string', 'description': 'The version of the project as supported by :pep:`440`.', 'format': 'pep440'}, 'description': {'type': 'string', '$$description': ['The `summary description of the project', '`_']}, 'readme': {'$$description': ['`Full/detailed description of the project in the form of a README', '`_', "with meaning similar to the one defined in `core metadata's Description", '`_'], 'oneOf': [{'type': 'string', '$$description': ['Relative path to a text file (UTF-8) containing the full description', 'of the project. If the file path ends in case-insensitive ``.md`` or', '``.rst`` suffixes, then the content-type is respectively', '``text/markdown`` or ``text/x-rst``']}, {'type': 'object', 'allOf': [{'anyOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to a text file containing the full description', 'of the project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', 'description': 'Full text describing the project.'}}, 'required': ['text']}]}, {'properties': {'content-type': {'type': 'string', '$$description': ['Content-type (:rfc:`1341`) of the full description', '(e.g. ``text/markdown``). The ``charset`` parameter is assumed', 'UTF-8 when not present.'], '$comment': 'TODO: add regex pattern or format?'}}, 'required': ['content-type']}]}]}, 'requires-python': {'type': 'string', 'format': 'pep508-versionspec', '$$description': ['`The Python version requirements of the project', '`_.']}, 'license': {'description': '`Project license `_.', 'oneOf': [{'properties': {'file': {'type': 'string', '$$description': ['Relative path to the file (UTF-8) which contains the license for the', 'project.']}}, 'required': ['file']}, {'properties': {'text': {'type': 'string', '$$description': ['The license of the project whose meaning is that of the', '`License field from the core metadata', '`_.']}}, 'required': ['text']}]}, 'authors': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'authors' of the project.", 'The exact meaning is open to interpretation (e.g. original or primary authors,', 'current maintainers, or owners of the package).']}, 'maintainers': {'type': 'array', 'items': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, '$$description': ["The people or organizations considered to be the 'maintainers' of the project.", 'Similarly to ``authors``, the exact meaning is open to interpretation.']}, 'keywords': {'type': 'array', 'items': {'type': 'string'}, 'description': 'List of keywords to assist searching for the distribution in a larger catalog.'}, 'classifiers': {'type': 'array', 'items': {'type': 'string', 'format': 'trove-classifier', 'description': '`PyPI classifier `_.'}, '$$description': ['`Trove classifiers `_', 'which apply to the project.']}, 'urls': {'type': 'object', 'description': 'URLs associated with the project in the form ``label => value``.', 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', 'format': 'url'}}}, 'scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'gui-scripts': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'entry-points': {'$$description': ['Instruct the installer to expose the given modules/functions via', '``entry-point`` discovery mechanism (useful for plugins).', 'More information available in the `Python packaging guide', '`_.'], 'propertyNames': {'format': 'python-entrypoint-group'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}}}, 'dependencies': {'type': 'array', 'description': 'Project (mandatory) dependencies.', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}, 'optional-dependencies': {'type': 'object', 'description': 'Optional dependency for the project', 'propertyNames': {'format': 'pep508-identifier'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'array', 'items': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}}, 'dynamic': {'type': 'array', '$$description': ['Specifies which fields are intentionally unspecified and expected to be', 'dynamically provided by build tools'], 'items': {'enum': ['version', 'description', 'readme', 'requires-python', 'license', 'authors', 'maintainers', 'keywords', 'classifiers', 'urls', 'scripts', 'gui-scripts', 'entry-points', 'dependencies', 'optional-dependencies']}}}, 'required': ['name'], 'additionalProperties': False, 'if': {'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, 'then': {'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, 'definitions': {'author': {'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, 'entry-point-group': {'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, 'dependency': {'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}}}, rule='additionalProperties')
    try:
        try:
            data_is_dict = isinstance(data, dict)
            if data_is_dict:
                data_len = len(data)
                if not all(prop in data for prop in ['dynamic']):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain ['dynamic'] properties", value=data, name="" + (name_prefix or "data") + "", definition={'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, rule='required')
                data_keys = set(data.keys())
                if "dynamic" in data_keys:
                    data_keys.remove("dynamic")
                    data__dynamic = data["dynamic"]
                    data__dynamic_is_list = isinstance(data__dynamic, (list, tuple))
                    if data__dynamic_is_list:
                        data__dynamic_contains = False
                        for data__dynamic_key in data__dynamic:
                            try:
                                if data__dynamic_key != "version":
                                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must be same as const definition: version", value=data__dynamic_key, name="" + (name_prefix or "data") + ".dynamic", definition={'const': 'version'}, rule='const')
                                data__dynamic_contains = True
                                break
                            except JsonSchemaValueException: pass
                        if not data__dynamic_contains:
                            raise JsonSchemaValueException("" + (name_prefix or "data") + ".dynamic must contain one of contains definition", value=data__dynamic, name="" + (name_prefix or "data") + ".dynamic", definition={'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}, rule='contains')
        except JsonSchemaValueException: pass
        else:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must NOT match a disallowed definition", value=data, name="" + (name_prefix or "data") + "", definition={'not': {'required': ['dynamic'], 'properties': {'dynamic': {'contains': {'const': 'version'}, '$$description': ['version is listed in ``dynamic``']}}}, '$$comment': ['According to :pep:`621`:', '    If the core metadata specification lists a field as "Required", then', '    the metadata MUST specify the field statically or list it in dynamic', 'In turn, `core metadata`_ defines:', '    The required fields are: Metadata-Version, Name, Version.', '    All the other fields are optional.', 'Since ``Metadata-Version`` is defined by the build back-end, ``name`` and', '``version`` are the only mandatory information in ``pyproject.toml``.', '.. _core metadata: https://packaging.python.org/specifications/core-metadata/']}, rule='not')
    except JsonSchemaValueException:
        pass
    else:
        data_is_dict = isinstance(data, dict)
        if data_is_dict:
            data_len = len(data)
            if not all(prop in data for prop in ['version']):
                raise JsonSchemaValueException("" + (name_prefix or "data") + " must contain ['version'] properties", value=data, name="" + (name_prefix or "data") + "", definition={'required': ['version'], '$$description': ['version should be statically defined in the ``version`` field']}, rule='required')
    return data

def validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_dependency(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (str)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be string", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}, rule='type')
    if isinstance(data, str):
        if not custom_formats["pep508"](data):
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must be pep508", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/dependency', 'title': 'Dependency', 'type': 'string', 'description': 'Project dependency specification according to PEP 508', 'format': 'pep508'}, rule='format')
    return data

def validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_entry_point_group(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_keys = set(data.keys())
        for data_key, data_val in data.items():
            if REGEX_PATTERNS['^.+$'].search(data_key):
                if data_key in data_keys:
                    data_keys.remove(data_key)
                if not isinstance(data_val, (str)):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".{data_key}".format(**locals()) + " must be string", value=data_val, name="" + (name_prefix or "data") + ".{data_key}".format(**locals()) + "", definition={'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}, rule='type')
                if isinstance(data_val, str):
                    if not custom_formats["python-entrypoint-reference"](data_val):
                        raise JsonSchemaValueException("" + (name_prefix or "data") + ".{data_key}".format(**locals()) + " must be python-entrypoint-reference", value=data_val, name="" + (name_prefix or "data") + ".{data_key}".format(**locals()) + "", definition={'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}, rule='format')
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, rule='additionalProperties')
        data_len = len(data)
        if data_len != 0:
            data_property_names = True
            for data_key in data:
                try:
                    if isinstance(data_key, str):
                        if not custom_formats["python-entrypoint-name"](data_key):
                            raise JsonSchemaValueException("" + (name_prefix or "data") + " must be python-entrypoint-name", value=data_key, name="" + (name_prefix or "data") + "", definition={'format': 'python-entrypoint-name'}, rule='format')
                except JsonSchemaValueException:
                    data_property_names = False
            if not data_property_names:
                raise JsonSchemaValueException("" + (name_prefix or "data") + " must be named by propertyName definition", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/entry-point-group', 'title': 'Entry-points', 'type': 'object', '$$description': ['Entry-points are grouped together to indicate what sort of capabilities they', 'provide.', 'See the `packaging guides', '`_', 'and `setuptools docs', '`_', 'for more information.'], 'propertyNames': {'format': 'python-entrypoint-name'}, 'additionalProperties': False, 'patternProperties': {'^.+$': {'type': 'string', '$$description': ['Reference to a Python object. It is either in the form', '``importable.module``, or ``importable.module:object.attr``.'], 'format': 'python-entrypoint-reference', '$comment': 'https://packaging.python.org/specifications/entry-points/'}}}, rule='propertyNames')
    return data

def validate_https___packaging_python_org_en_latest_specifications_declaring_project_metadata___definitions_author(data, custom_formats={}, name_prefix=None):
    if not isinstance(data, (dict)):
        raise JsonSchemaValueException("" + (name_prefix or "data") + " must be object", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, rule='type')
    data_is_dict = isinstance(data, dict)
    if data_is_dict:
        data_keys = set(data.keys())
        if "name" in data_keys:
            data_keys.remove("name")
            data__name = data["name"]
            if not isinstance(data__name, (str)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".name must be string", value=data__name, name="" + (name_prefix or "data") + ".name", definition={'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, rule='type')
        if "email" in data_keys:
            data_keys.remove("email")
            data__email = data["email"]
            if not isinstance(data__email, (str)):
                raise JsonSchemaValueException("" + (name_prefix or "data") + ".email must be string", value=data__email, name="" + (name_prefix or "data") + ".email", definition={'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}, rule='type')
            if isinstance(data__email, str):
                if not REGEX_PATTERNS["idn-email_re_pattern"].match(data__email):
                    raise JsonSchemaValueException("" + (name_prefix or "data") + ".email must be idn-email", value=data__email, name="" + (name_prefix or "data") + ".email", definition={'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}, rule='format')
        if data_keys:
            raise JsonSchemaValueException("" + (name_prefix or "data") + " must not contain "+str(data_keys)+" properties", value=data, name="" + (name_prefix or "data") + "", definition={'$id': '#/definitions/author', 'title': 'Author or Maintainer', '$comment': 'https://peps.python.org/pep-0621/#authors-maintainers', 'type': 'object', 'additionalProperties': False, 'properties': {'name': {'type': 'string', '$$description': ['MUST be a valid email name, i.e. whatever can be put as a name, before an', 'email, in :rfc:`822`.']}, 'email': {'type': 'string', 'format': 'idn-email', 'description': 'MUST be a valid email address'}}}, rule='additionalProperties')
    return data
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/_validate_pyproject/formats.py0000644000175100001730000002171014467657412025215 0ustar00runnerdockerimport logging
import os
import re
import string
import typing
from itertools import chain as _chain

if typing.TYPE_CHECKING:
    from typing_extensions import Literal

_logger = logging.getLogger(__name__)

# -------------------------------------------------------------------------------------
# PEP 440

VERSION_PATTERN = r"""
    v?
    (?:
        (?:(?P[0-9]+)!)?                           # epoch
        (?P[0-9]+(?:\.[0-9]+)*)                  # release segment
        (?P
                                          # pre-release
            [-_\.]?
            (?P(a|b|c|rc|alpha|beta|pre|preview))
            [-_\.]?
            (?P[0-9]+)?
        )?
        (?P                                         # post release
            (?:-(?P[0-9]+))
            |
            (?:
                [-_\.]?
                (?Ppost|rev|r)
                [-_\.]?
                (?P[0-9]+)?
            )
        )?
        (?P                                          # dev release
            [-_\.]?
            (?Pdev)
            [-_\.]?
            (?P[0-9]+)?
        )?
    )
    (?:\+(?P[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
"""

VERSION_REGEX = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.X | re.I)


def pep440(version: str) -> bool:
    return VERSION_REGEX.match(version) is not None


# -------------------------------------------------------------------------------------
# PEP 508

PEP508_IDENTIFIER_PATTERN = r"([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])"
PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.I)


def pep508_identifier(name: str) -> bool:
    return PEP508_IDENTIFIER_REGEX.match(name) is not None


try:
    try:
        from packaging import requirements as _req
    except ImportError:  # pragma: no cover
        # let's try setuptools vendored version
        from setuptools._vendor.packaging import requirements as _req  # type: ignore

    def pep508(value: str) -> bool:
        try:
            _req.Requirement(value)
            return True
        except _req.InvalidRequirement:
            return False

except ImportError:  # pragma: no cover
    _logger.warning(
        "Could not find an installation of `packaging`. Requirements, dependencies and "
        "versions might not be validated. "
        "To enforce validation, please install `packaging`."
    )

    def pep508(value: str) -> bool:
        return True


def pep508_versionspec(value: str) -> bool:
    """Expression that can be used to specify/lock versions (including ranges)"""
    if any(c in value for c in (";", "]", "@")):
        # In PEP 508:
        # conditional markers, extras and URL specs are not included in the
        # versionspec
        return False
    # Let's pretend we have a dependency called `requirement` with the given
    # version spec, then we can reuse the pep508 function for validation:
    return pep508(f"requirement{value}")


# -------------------------------------------------------------------------------------
# PEP 517


def pep517_backend_reference(value: str) -> bool:
    module, _, obj = value.partition(":")
    identifiers = (i.strip() for i in _chain(module.split("."), obj.split(".")))
    return all(python_identifier(i) for i in identifiers if i)


# -------------------------------------------------------------------------------------
# Classifiers - PEP 301


def _download_classifiers() -> str:
    import ssl
    from email.message import Message
    from urllib.request import urlopen

    url = "https://pypi.org/pypi?:action=list_classifiers"
    context = ssl.create_default_context()
    with urlopen(url, context=context) as response:
        headers = Message()
        headers["content_type"] = response.getheader("content-type", "text/plain")
        return response.read().decode(headers.get_param("charset", "utf-8"))


class _TroveClassifier:
    """The ``trove_classifiers`` package is the official way of validating classifiers,
    however this package might not be always available.
    As a workaround we can still download a list from PyPI.
    We also don't want to be over strict about it, so simply skipping silently is an
    option (classifiers will be validated anyway during the upload to PyPI).
    """

    downloaded: typing.Union[None, "Literal[False]", typing.Set[str]]

    def __init__(self):
        self.downloaded = None
        self._skip_download = False
        # None => not cached yet
        # False => cache not available
        self.__name__ = "trove_classifier"  # Emulate a public function

    def _disable_download(self):
        # This is a private API. Only setuptools has the consent of using it.
        self._skip_download = True

    def __call__(self, value: str) -> bool:
        if self.downloaded is False or self._skip_download is True:
            return True

        if os.getenv("NO_NETWORK") or os.getenv("VALIDATE_PYPROJECT_NO_NETWORK"):
            self.downloaded = False
            msg = (
                "Install ``trove-classifiers`` to ensure proper validation. "
                "Skipping download of classifiers list from PyPI (NO_NETWORK)."
            )
            _logger.debug(msg)
            return True

        if self.downloaded is None:
            msg = (
                "Install ``trove-classifiers`` to ensure proper validation. "
                "Meanwhile a list of classifiers will be downloaded from PyPI."
            )
            _logger.debug(msg)
            try:
                self.downloaded = set(_download_classifiers().splitlines())
            except Exception:
                self.downloaded = False
                _logger.debug("Problem with download, skipping validation")
                return True

        return value in self.downloaded or value.lower().startswith("private ::")


try:
    from trove_classifiers import classifiers as _trove_classifiers

    def trove_classifier(value: str) -> bool:
        return value in _trove_classifiers or value.lower().startswith("private ::")

except ImportError:  # pragma: no cover
    trove_classifier = _TroveClassifier()


# -------------------------------------------------------------------------------------
# Stub packages - PEP 561


def pep561_stub_name(value: str) -> bool:
    top, *children = value.split(".")
    if not top.endswith("-stubs"):
        return False
    return python_module_name(".".join([top[: -len("-stubs")], *children]))


# -------------------------------------------------------------------------------------
# Non-PEP related


def url(value: str) -> bool:
    from urllib.parse import urlparse

    try:
        parts = urlparse(value)
        if not parts.scheme:
            _logger.warning(
                "For maximum compatibility please make sure to include a "
                "`scheme` prefix in your URL (e.g. 'http://'). "
                f"Given value: {value}"
            )
            if not (value.startswith("/") or value.startswith("\\") or "@" in value):
                parts = urlparse(f"http://{value}")

        return bool(parts.scheme and parts.netloc)
    except Exception:
        return False


# https://packaging.python.org/specifications/entry-points/
ENTRYPOINT_PATTERN = r"[^\[\s=]([^=]*[^\s=])?"
ENTRYPOINT_REGEX = re.compile(f"^{ENTRYPOINT_PATTERN}$", re.I)
RECOMMEDED_ENTRYPOINT_PATTERN = r"[\w.-]+"
RECOMMEDED_ENTRYPOINT_REGEX = re.compile(f"^{RECOMMEDED_ENTRYPOINT_PATTERN}$", re.I)
ENTRYPOINT_GROUP_PATTERN = r"\w+(\.\w+)*"
ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.I)


def python_identifier(value: str) -> bool:
    return value.isidentifier()


def python_qualified_identifier(value: str) -> bool:
    if value.startswith(".") or value.endswith("."):
        return False
    return all(python_identifier(m) for m in value.split("."))


def python_module_name(value: str) -> bool:
    return python_qualified_identifier(value)


def python_entrypoint_group(value: str) -> bool:
    return ENTRYPOINT_GROUP_REGEX.match(value) is not None


def python_entrypoint_name(value: str) -> bool:
    if not ENTRYPOINT_REGEX.match(value):
        return False
    if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):
        msg = f"Entry point `{value}` does not follow recommended pattern: "
        msg += RECOMMEDED_ENTRYPOINT_PATTERN
        _logger.warning(msg)
    return True


def python_entrypoint_reference(value: str) -> bool:
    module, _, rest = value.partition(":")
    if "[" in rest:
        obj, _, extras_ = rest.partition("[")
        if extras_.strip()[-1] != "]":
            return False
        extras = (x.strip() for x in extras_.strip(string.whitespace + "[]").split(","))
        if not all(pep508_identifier(e) for e in extras):
            return False
        _logger.warning(f"`{value}` - using extras for entry points is not recommended")
    else:
        obj = rest

    module_parts = module.split(".")
    identifiers = _chain(module_parts, obj.split(".")) if rest else module_parts
    return all(python_identifier(i.strip()) for i in identifiers)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/expand.py0000644000175100001730000004002114467657412020766 0ustar00runnerdocker"""Utility functions to expand configuration directives or special values
(such glob patterns).

We can split the process of interpreting configuration files into 2 steps:

1. The parsing the file contents from strings to value objects
   that can be understand by Python (for example a string with a comma
   separated list of keywords into an actual Python list of strings).

2. The expansion (or post-processing) of these values according to the
   semantics ``setuptools`` assign to them (for example a configuration field
   with the ``file:`` directive should be expanded from a list of file paths to
   a single string with the contents of those files concatenated)

This module focus on the second step, and therefore allow sharing the expansion
functions among several configuration file formats.

**PRIVATE MODULE**: API reserved for setuptools internal usage only.
"""
import ast
import importlib
import io
import os
import pathlib
import sys
from glob import iglob
from configparser import ConfigParser
from importlib.machinery import ModuleSpec
from itertools import chain
from typing import (
    TYPE_CHECKING,
    Callable,
    Dict,
    Iterable,
    Iterator,
    List,
    Mapping,
    Optional,
    Tuple,
    TypeVar,
    Union,
    cast,
)
from pathlib import Path
from types import ModuleType

from distutils.errors import DistutilsOptionError

from .._path import same_path as _same_path
from ..warnings import SetuptoolsWarning

if TYPE_CHECKING:
    from setuptools.dist import Distribution  # noqa
    from setuptools.discovery import ConfigDiscovery  # noqa
    from distutils.dist import DistributionMetadata  # noqa

chain_iter = chain.from_iterable
_Path = Union[str, os.PathLike]
_K = TypeVar("_K")
_V = TypeVar("_V", covariant=True)


class StaticModule:
    """Proxy to a module object that avoids executing arbitrary code."""

    def __init__(self, name: str, spec: ModuleSpec):
        module = ast.parse(pathlib.Path(spec.origin).read_bytes())
        vars(self).update(locals())
        del self.self

    def _find_assignments(self) -> Iterator[Tuple[ast.AST, ast.AST]]:
        for statement in self.module.body:
            if isinstance(statement, ast.Assign):
                yield from ((target, statement.value) for target in statement.targets)
            elif isinstance(statement, ast.AnnAssign) and statement.value:
                yield (statement.target, statement.value)

    def __getattr__(self, attr):
        """Attempt to load an attribute "statically", via :func:`ast.literal_eval`."""
        try:
            return next(
                ast.literal_eval(value)
                for target, value in self._find_assignments()
                if isinstance(target, ast.Name) and target.id == attr
            )
        except Exception as e:
            raise AttributeError(f"{self.name} has no attribute {attr}") from e


def glob_relative(
    patterns: Iterable[str], root_dir: Optional[_Path] = None
) -> List[str]:
    """Expand the list of glob patterns, but preserving relative paths.

    :param list[str] patterns: List of glob patterns
    :param str root_dir: Path to which globs should be relative
                         (current directory by default)
    :rtype: list
    """
    glob_characters = {'*', '?', '[', ']', '{', '}'}
    expanded_values = []
    root_dir = root_dir or os.getcwd()
    for value in patterns:
        # Has globby characters?
        if any(char in value for char in glob_characters):
            # then expand the glob pattern while keeping paths *relative*:
            glob_path = os.path.abspath(os.path.join(root_dir, value))
            expanded_values.extend(
                sorted(
                    os.path.relpath(path, root_dir).replace(os.sep, "/")
                    for path in iglob(glob_path, recursive=True)
                )
            )

        else:
            # take the value as-is
            path = os.path.relpath(value, root_dir).replace(os.sep, "/")
            expanded_values.append(path)

    return expanded_values


def read_files(filepaths: Union[str, bytes, Iterable[_Path]], root_dir=None) -> str:
    """Return the content of the files concatenated using ``\n`` as str

    This function is sandboxed and won't reach anything outside ``root_dir``

    (By default ``root_dir`` is the current directory).
    """
    from setuptools.extern.more_itertools import always_iterable

    root_dir = os.path.abspath(root_dir or os.getcwd())
    _filepaths = (os.path.join(root_dir, path) for path in always_iterable(filepaths))
    return '\n'.join(
        _read_file(path)
        for path in _filter_existing_files(_filepaths)
        if _assert_local(path, root_dir)
    )


def _filter_existing_files(filepaths: Iterable[_Path]) -> Iterator[_Path]:
    for path in filepaths:
        if os.path.isfile(path):
            yield path
        else:
            SetuptoolsWarning.emit(f"File {path!r} cannot be found")


def _read_file(filepath: Union[bytes, _Path]) -> str:
    with io.open(filepath, encoding='utf-8') as f:
        return f.read()


def _assert_local(filepath: _Path, root_dir: str):
    if Path(os.path.abspath(root_dir)) not in Path(os.path.abspath(filepath)).parents:
        msg = f"Cannot access {filepath!r} (or anything outside {root_dir!r})"
        raise DistutilsOptionError(msg)

    return True


def read_attr(
    attr_desc: str,
    package_dir: Optional[Mapping[str, str]] = None,
    root_dir: Optional[_Path] = None,
):
    """Reads the value of an attribute from a module.

    This function will try to read the attributed statically first
    (via :func:`ast.literal_eval`), and only evaluate the module if it fails.

    Examples:
        read_attr("package.attr")
        read_attr("package.module.attr")

    :param str attr_desc: Dot-separated string describing how to reach the
        attribute (see examples above)
    :param dict[str, str] package_dir: Mapping of package names to their
        location in disk (represented by paths relative to ``root_dir``).
    :param str root_dir: Path to directory containing all the packages in
        ``package_dir`` (current directory by default).
    :rtype: str
    """
    root_dir = root_dir or os.getcwd()
    attrs_path = attr_desc.strip().split('.')
    attr_name = attrs_path.pop()
    module_name = '.'.join(attrs_path)
    module_name = module_name or '__init__'
    _parent_path, path, module_name = _find_module(module_name, package_dir, root_dir)
    spec = _find_spec(module_name, path)

    try:
        return getattr(StaticModule(module_name, spec), attr_name)
    except Exception:
        # fallback to evaluate module
        module = _load_spec(spec, module_name)
        return getattr(module, attr_name)


def _find_spec(module_name: str, module_path: Optional[_Path]) -> ModuleSpec:
    spec = importlib.util.spec_from_file_location(module_name, module_path)
    spec = spec or importlib.util.find_spec(module_name)

    if spec is None:
        raise ModuleNotFoundError(module_name)

    return spec


def _load_spec(spec: ModuleSpec, module_name: str) -> ModuleType:
    name = getattr(spec, "__name__", module_name)
    if name in sys.modules:
        return sys.modules[name]
    module = importlib.util.module_from_spec(spec)
    sys.modules[name] = module  # cache (it also ensures `==` works on loaded items)
    spec.loader.exec_module(module)  # type: ignore
    return module


def _find_module(
    module_name: str, package_dir: Optional[Mapping[str, str]], root_dir: _Path
) -> Tuple[_Path, Optional[str], str]:
    """Given a module (that could normally be imported by ``module_name``
    after the build is complete), find the path to the parent directory where
    it is contained and the canonical name that could be used to import it
    considering the ``package_dir`` in the build configuration and ``root_dir``
    """
    parent_path = root_dir
    module_parts = module_name.split('.')
    if package_dir:
        if module_parts[0] in package_dir:
            # A custom path was specified for the module we want to import
            custom_path = package_dir[module_parts[0]]
            parts = custom_path.rsplit('/', 1)
            if len(parts) > 1:
                parent_path = os.path.join(root_dir, parts[0])
                parent_module = parts[1]
            else:
                parent_module = custom_path
            module_name = ".".join([parent_module, *module_parts[1:]])
        elif '' in package_dir:
            # A custom parent directory was specified for all root modules
            parent_path = os.path.join(root_dir, package_dir[''])

    path_start = os.path.join(parent_path, *module_name.split("."))
    candidates = chain(
        (f"{path_start}.py", os.path.join(path_start, "__init__.py")),
        iglob(f"{path_start}.*"),
    )
    module_path = next((x for x in candidates if os.path.isfile(x)), None)
    return parent_path, module_path, module_name


def resolve_class(
    qualified_class_name: str,
    package_dir: Optional[Mapping[str, str]] = None,
    root_dir: Optional[_Path] = None,
) -> Callable:
    """Given a qualified class name, return the associated class object"""
    root_dir = root_dir or os.getcwd()
    idx = qualified_class_name.rfind('.')
    class_name = qualified_class_name[idx + 1 :]
    pkg_name = qualified_class_name[:idx]

    _parent_path, path, module_name = _find_module(pkg_name, package_dir, root_dir)
    module = _load_spec(_find_spec(module_name, path), module_name)
    return getattr(module, class_name)


def cmdclass(
    values: Dict[str, str],
    package_dir: Optional[Mapping[str, str]] = None,
    root_dir: Optional[_Path] = None,
) -> Dict[str, Callable]:
    """Given a dictionary mapping command names to strings for qualified class
    names, apply :func:`resolve_class` to the dict values.
    """
    return {k: resolve_class(v, package_dir, root_dir) for k, v in values.items()}


def find_packages(
    *,
    namespaces=True,
    fill_package_dir: Optional[Dict[str, str]] = None,
    root_dir: Optional[_Path] = None,
    **kwargs,
) -> List[str]:
    """Works similarly to :func:`setuptools.find_packages`, but with all
    arguments given as keyword arguments. Moreover, ``where`` can be given
    as a list (the results will be simply concatenated).

    When the additional keyword argument ``namespaces`` is ``True``, it will
    behave like :func:`setuptools.find_namespace_packages`` (i.e. include
    implicit namespaces as per :pep:`420`).

    The ``where`` argument will be considered relative to ``root_dir`` (or the current
    working directory when ``root_dir`` is not given).

    If the ``fill_package_dir`` argument is passed, this function will consider it as a
    similar data structure to the ``package_dir`` configuration parameter add fill-in
    any missing package location.

    :rtype: list
    """
    from setuptools.discovery import construct_package_dir
    from setuptools.extern.more_itertools import unique_everseen, always_iterable

    if namespaces:
        from setuptools.discovery import PEP420PackageFinder as PackageFinder
    else:
        from setuptools.discovery import PackageFinder  # type: ignore

    root_dir = root_dir or os.curdir
    where = kwargs.pop('where', ['.'])
    packages: List[str] = []
    fill_package_dir = {} if fill_package_dir is None else fill_package_dir
    search = list(unique_everseen(always_iterable(where)))

    if len(search) == 1 and all(not _same_path(search[0], x) for x in (".", root_dir)):
        fill_package_dir.setdefault("", search[0])

    for path in search:
        package_path = _nest_path(root_dir, path)
        pkgs = PackageFinder.find(package_path, **kwargs)
        packages.extend(pkgs)
        if pkgs and not (
            fill_package_dir.get("") == path or os.path.samefile(package_path, root_dir)
        ):
            fill_package_dir.update(construct_package_dir(pkgs, path))

    return packages


def _nest_path(parent: _Path, path: _Path) -> str:
    path = parent if path in {".", ""} else os.path.join(parent, path)
    return os.path.normpath(path)


def version(value: Union[Callable, Iterable[Union[str, int]], str]) -> str:
    """When getting the version directly from an attribute,
    it should be normalised to string.
    """
    if callable(value):
        value = value()

    value = cast(Iterable[Union[str, int]], value)

    if not isinstance(value, str):
        if hasattr(value, '__iter__'):
            value = '.'.join(map(str, value))
        else:
            value = '%s' % value

    return value


def canonic_package_data(package_data: dict) -> dict:
    if "*" in package_data:
        package_data[""] = package_data.pop("*")
    return package_data


def canonic_data_files(
    data_files: Union[list, dict], root_dir: Optional[_Path] = None
) -> List[Tuple[str, List[str]]]:
    """For compatibility with ``setup.py``, ``data_files`` should be a list
    of pairs instead of a dict.

    This function also expands glob patterns.
    """
    if isinstance(data_files, list):
        return data_files

    return [
        (dest, glob_relative(patterns, root_dir))
        for dest, patterns in data_files.items()
    ]


def entry_points(text: str, text_source="entry-points") -> Dict[str, dict]:
    """Given the contents of entry-points file,
    process it into a 2-level dictionary (``dict[str, dict[str, str]]``).
    The first level keys are entry-point groups, the second level keys are
    entry-point names, and the second level values are references to objects
    (that correspond to the entry-point value).
    """
    parser = ConfigParser(default_section=None, delimiters=("=",))  # type: ignore
    parser.optionxform = str  # case sensitive
    parser.read_string(text, text_source)
    groups = {k: dict(v.items()) for k, v in parser.items()}
    groups.pop(parser.default_section, None)
    return groups


class EnsurePackagesDiscovered:
    """Some expand functions require all the packages to already be discovered before
    they run, e.g. :func:`read_attr`, :func:`resolve_class`, :func:`cmdclass`.

    Therefore in some cases we will need to run autodiscovery during the evaluation of
    the configuration. However, it is better to postpone calling package discovery as
    much as possible, because some parameters can influence it (e.g. ``package_dir``),
    and those might not have been processed yet.
    """

    def __init__(self, distribution: "Distribution"):
        self._dist = distribution
        self._called = False

    def __call__(self):
        """Trigger the automatic package discovery, if it is still necessary."""
        if not self._called:
            self._called = True
            self._dist.set_defaults(name=False)  # Skip name, we can still be parsing

    def __enter__(self):
        return self

    def __exit__(self, _exc_type, _exc_value, _traceback):
        if self._called:
            self._dist.set_defaults.analyse_name()  # Now we can set a default name

    def _get_package_dir(self) -> Mapping[str, str]:
        self()
        pkg_dir = self._dist.package_dir
        return {} if pkg_dir is None else pkg_dir

    @property
    def package_dir(self) -> Mapping[str, str]:
        """Proxy to ``package_dir`` that may trigger auto-discovery when used."""
        return LazyMappingProxy(self._get_package_dir)


class LazyMappingProxy(Mapping[_K, _V]):
    """Mapping proxy that delays resolving the target object, until really needed.

    >>> def obtain_mapping():
    ...     print("Running expensive function!")
    ...     return {"key": "value", "other key": "other value"}
    >>> mapping = LazyMappingProxy(obtain_mapping)
    >>> mapping["key"]
    Running expensive function!
    'value'
    >>> mapping["other key"]
    'other value'
    """

    def __init__(self, obtain_mapping_value: Callable[[], Mapping[_K, _V]]):
        self._obtain = obtain_mapping_value
        self._value: Optional[Mapping[_K, _V]] = None

    def _target(self) -> Mapping[_K, _V]:
        if self._value is None:
            self._value = self._obtain()
        return self._value

    def __getitem__(self, key: _K) -> _V:
        return self._target()[key]

    def __len__(self) -> int:
        return len(self._target())

    def __iter__(self) -> Iterator[_K]:
        return iter(self._target())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/pyprojecttoml.py0000644000175100001730000004212214467657412022426 0ustar00runnerdocker"""
Load setuptools configuration from ``pyproject.toml`` files.

**PRIVATE MODULE**: API reserved for setuptools internal usage only.

To read project metadata, consider using
``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
For simple scenarios, you can also try parsing the file directly
with the help of ``tomllib`` or ``tomli``.
"""
import logging
import os
from contextlib import contextmanager
from functools import partial
from typing import TYPE_CHECKING, Callable, Dict, Mapping, Optional, Set, Union

from ..errors import FileError, OptionError
from ..warnings import SetuptoolsWarning
from . import expand as _expand
from ._apply_pyprojecttoml import _PREVIOUSLY_DEFINED, _WouldIgnoreField
from ._apply_pyprojecttoml import apply as _apply

if TYPE_CHECKING:
    from setuptools.dist import Distribution  # noqa

_Path = Union[str, os.PathLike]
_logger = logging.getLogger(__name__)


def load_file(filepath: _Path) -> dict:
    from setuptools.extern import tomli  # type: ignore

    with open(filepath, "rb") as file:
        return tomli.load(file)


def validate(config: dict, filepath: _Path) -> bool:
    from . import _validate_pyproject as validator

    trove_classifier = validator.FORMAT_FUNCTIONS.get("trove-classifier")
    if hasattr(trove_classifier, "_disable_download"):
        # Improve reproducibility by default. See issue 31 for validate-pyproject.
        trove_classifier._disable_download()  # type: ignore

    try:
        return validator.validate(config)
    except validator.ValidationError as ex:
        summary = f"configuration error: {ex.summary}"
        if ex.name.strip("`") != "project":
            # Probably it is just a field missing/misnamed, not worthy the verbosity...
            _logger.debug(summary)
            _logger.debug(ex.details)

        error = f"invalid pyproject.toml config: {ex.name}."
        raise ValueError(f"{error}\n{summary}") from None


def apply_configuration(
    dist: "Distribution",
    filepath: _Path,
    ignore_option_errors=False,
) -> "Distribution":
    """Apply the configuration from a ``pyproject.toml`` file into an existing
    distribution object.
    """
    config = read_configuration(filepath, True, ignore_option_errors, dist)
    return _apply(dist, config, filepath)


def read_configuration(
    filepath: _Path,
    expand=True,
    ignore_option_errors=False,
    dist: Optional["Distribution"] = None,
):
    """Read given configuration file and returns options from it as a dict.

    :param str|unicode filepath: Path to configuration file in the ``pyproject.toml``
        format.

    :param bool expand: Whether to expand directives and other computed values
        (i.e. post-process the given configuration)

    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.

    :param Distribution|None: Distribution object to which the configuration refers.
        If not given a dummy object will be created and discarded after the
        configuration is read. This is used for auto-discovery of packages and in the
        case a dynamic configuration (e.g. ``attr`` or ``cmdclass``) is expanded.
        When ``expand=False`` this object is simply ignored.

    :rtype: dict
    """
    filepath = os.path.abspath(filepath)

    if not os.path.isfile(filepath):
        raise FileError(f"Configuration file {filepath!r} does not exist.")

    asdict = load_file(filepath) or {}
    project_table = asdict.get("project", {})
    tool_table = asdict.get("tool", {})
    setuptools_table = tool_table.get("setuptools", {})
    if not asdict or not (project_table or setuptools_table):
        return {}  # User is not using pyproject to configure setuptools

    if "distutils" in tool_table:
        _ExperimentalConfiguration.emit(subject="[tool.distutils]")

    # There is an overall sense in the community that making include_package_data=True
    # the default would be an improvement.
    # `ini2toml` backfills include_package_data=False when nothing is explicitly given,
    # therefore setting a default here is backwards compatible.
    if dist and getattr(dist, "include_package_data", None) is not None:
        setuptools_table.setdefault("include-package-data", dist.include_package_data)
    else:
        setuptools_table.setdefault("include-package-data", True)
    # Persist changes:
    asdict["tool"] = tool_table
    tool_table["setuptools"] = setuptools_table

    with _ignore_errors(ignore_option_errors):
        # Don't complain about unrelated errors (e.g. tools not using the "tool" table)
        subset = {"project": project_table, "tool": {"setuptools": setuptools_table}}
        validate(subset, filepath)

    if expand:
        root_dir = os.path.dirname(filepath)
        return expand_configuration(asdict, root_dir, ignore_option_errors, dist)

    return asdict


def expand_configuration(
    config: dict,
    root_dir: Optional[_Path] = None,
    ignore_option_errors: bool = False,
    dist: Optional["Distribution"] = None,
) -> dict:
    """Given a configuration with unresolved fields (e.g. dynamic, cmdclass, ...)
    find their final values.

    :param dict config: Dict containing the configuration for the distribution
    :param str root_dir: Top-level directory for the distribution/project
        (the same directory where ``pyproject.toml`` is place)
    :param bool ignore_option_errors: see :func:`read_configuration`
    :param Distribution|None: Distribution object to which the configuration refers.
        If not given a dummy object will be created and discarded after the
        configuration is read. Used in the case a dynamic configuration
        (e.g. ``attr`` or ``cmdclass``).

    :rtype: dict
    """
    return _ConfigExpander(config, root_dir, ignore_option_errors, dist).expand()


class _ConfigExpander:
    def __init__(
        self,
        config: dict,
        root_dir: Optional[_Path] = None,
        ignore_option_errors: bool = False,
        dist: Optional["Distribution"] = None,
    ):
        self.config = config
        self.root_dir = root_dir or os.getcwd()
        self.project_cfg = config.get("project", {})
        self.dynamic = self.project_cfg.get("dynamic", [])
        self.setuptools_cfg = config.get("tool", {}).get("setuptools", {})
        self.dynamic_cfg = self.setuptools_cfg.get("dynamic", {})
        self.ignore_option_errors = ignore_option_errors
        self._dist = dist
        self._referenced_files: Set[str] = set()

    def _ensure_dist(self) -> "Distribution":
        from setuptools.dist import Distribution

        attrs = {"src_root": self.root_dir, "name": self.project_cfg.get("name", None)}
        return self._dist or Distribution(attrs)

    def _process_field(self, container: dict, field: str, fn: Callable):
        if field in container:
            with _ignore_errors(self.ignore_option_errors):
                container[field] = fn(container[field])

    def _canonic_package_data(self, field="package-data"):
        package_data = self.setuptools_cfg.get(field, {})
        return _expand.canonic_package_data(package_data)

    def expand(self):
        self._expand_packages()
        self._canonic_package_data()
        self._canonic_package_data("exclude-package-data")

        # A distribution object is required for discovering the correct package_dir
        dist = self._ensure_dist()
        ctx = _EnsurePackagesDiscovered(dist, self.project_cfg, self.setuptools_cfg)
        with ctx as ensure_discovered:
            package_dir = ensure_discovered.package_dir
            self._expand_data_files()
            self._expand_cmdclass(package_dir)
            self._expand_all_dynamic(dist, package_dir)

        dist._referenced_files.update(self._referenced_files)
        return self.config

    def _expand_packages(self):
        packages = self.setuptools_cfg.get("packages")
        if packages is None or isinstance(packages, (list, tuple)):
            return

        find = packages.get("find")
        if isinstance(find, dict):
            find["root_dir"] = self.root_dir
            find["fill_package_dir"] = self.setuptools_cfg.setdefault("package-dir", {})
            with _ignore_errors(self.ignore_option_errors):
                self.setuptools_cfg["packages"] = _expand.find_packages(**find)

    def _expand_data_files(self):
        data_files = partial(_expand.canonic_data_files, root_dir=self.root_dir)
        self._process_field(self.setuptools_cfg, "data-files", data_files)

    def _expand_cmdclass(self, package_dir: Mapping[str, str]):
        root_dir = self.root_dir
        cmdclass = partial(_expand.cmdclass, package_dir=package_dir, root_dir=root_dir)
        self._process_field(self.setuptools_cfg, "cmdclass", cmdclass)

    def _expand_all_dynamic(self, dist: "Distribution", package_dir: Mapping[str, str]):
        special = (  # need special handling
            "version",
            "readme",
            "entry-points",
            "scripts",
            "gui-scripts",
            "classifiers",
            "dependencies",
            "optional-dependencies",
        )
        # `_obtain` functions are assumed to raise appropriate exceptions/warnings.
        obtained_dynamic = {
            field: self._obtain(dist, field, package_dir)
            for field in self.dynamic
            if field not in special
        }
        obtained_dynamic.update(
            self._obtain_entry_points(dist, package_dir) or {},
            version=self._obtain_version(dist, package_dir),
            readme=self._obtain_readme(dist),
            classifiers=self._obtain_classifiers(dist),
            dependencies=self._obtain_dependencies(dist),
            optional_dependencies=self._obtain_optional_dependencies(dist),
        )
        # `None` indicates there is nothing in `tool.setuptools.dynamic` but the value
        # might have already been set by setup.py/extensions, so avoid overwriting.
        updates = {k: v for k, v in obtained_dynamic.items() if v is not None}
        self.project_cfg.update(updates)

    def _ensure_previously_set(self, dist: "Distribution", field: str):
        previous = _PREVIOUSLY_DEFINED[field](dist)
        if previous is None and not self.ignore_option_errors:
            msg = (
                f"No configuration found for dynamic {field!r}.\n"
                "Some dynamic fields need to be specified via `tool.setuptools.dynamic`"
                "\nothers must be specified via the equivalent attribute in `setup.py`."
            )
            raise OptionError(msg)

    def _expand_directive(
        self, specifier: str, directive, package_dir: Mapping[str, str]
    ):
        from setuptools.extern.more_itertools import always_iterable  # type: ignore

        with _ignore_errors(self.ignore_option_errors):
            root_dir = self.root_dir
            if "file" in directive:
                self._referenced_files.update(always_iterable(directive["file"]))
                return _expand.read_files(directive["file"], root_dir)
            if "attr" in directive:
                return _expand.read_attr(directive["attr"], package_dir, root_dir)
            raise ValueError(f"invalid `{specifier}`: {directive!r}")
        return None

    def _obtain(self, dist: "Distribution", field: str, package_dir: Mapping[str, str]):
        if field in self.dynamic_cfg:
            return self._expand_directive(
                f"tool.setuptools.dynamic.{field}",
                self.dynamic_cfg[field],
                package_dir,
            )
        self._ensure_previously_set(dist, field)
        return None

    def _obtain_version(self, dist: "Distribution", package_dir: Mapping[str, str]):
        # Since plugins can set version, let's silently skip if it cannot be obtained
        if "version" in self.dynamic and "version" in self.dynamic_cfg:
            return _expand.version(self._obtain(dist, "version", package_dir))
        return None

    def _obtain_readme(self, dist: "Distribution") -> Optional[Dict[str, str]]:
        if "readme" not in self.dynamic:
            return None

        dynamic_cfg = self.dynamic_cfg
        if "readme" in dynamic_cfg:
            return {
                "text": self._obtain(dist, "readme", {}),
                "content-type": dynamic_cfg["readme"].get("content-type", "text/x-rst"),
            }

        self._ensure_previously_set(dist, "readme")
        return None

    def _obtain_entry_points(
        self, dist: "Distribution", package_dir: Mapping[str, str]
    ) -> Optional[Dict[str, dict]]:
        fields = ("entry-points", "scripts", "gui-scripts")
        if not any(field in self.dynamic for field in fields):
            return None

        text = self._obtain(dist, "entry-points", package_dir)
        if text is None:
            return None

        groups = _expand.entry_points(text)
        expanded = {"entry-points": groups}

        def _set_scripts(field: str, group: str):
            if group in groups:
                value = groups.pop(group)
                if field not in self.dynamic:
                    _WouldIgnoreField.emit(field=field, value=value)
                # TODO: Don't set field when support for pyproject.toml stabilizes
                #       instead raise an error as specified in PEP 621
                expanded[field] = value

        _set_scripts("scripts", "console_scripts")
        _set_scripts("gui-scripts", "gui_scripts")

        return expanded

    def _obtain_classifiers(self, dist: "Distribution"):
        if "classifiers" in self.dynamic:
            value = self._obtain(dist, "classifiers", {})
            if value:
                return value.splitlines()
        return None

    def _obtain_dependencies(self, dist: "Distribution"):
        if "dependencies" in self.dynamic:
            value = self._obtain(dist, "dependencies", {})
            if value:
                return _parse_requirements_list(value)
        return None

    def _obtain_optional_dependencies(self, dist: "Distribution"):
        if "optional-dependencies" not in self.dynamic:
            return None
        if "optional-dependencies" in self.dynamic_cfg:
            optional_dependencies_map = self.dynamic_cfg["optional-dependencies"]
            assert isinstance(optional_dependencies_map, dict)
            return {
                group: _parse_requirements_list(
                    self._expand_directive(
                        f"tool.setuptools.dynamic.optional-dependencies.{group}",
                        directive,
                        {},
                    )
                )
                for group, directive in optional_dependencies_map.items()
            }
        self._ensure_previously_set(dist, "optional-dependencies")
        return None


def _parse_requirements_list(value):
    return [
        line
        for line in value.splitlines()
        if line.strip() and not line.strip().startswith("#")
    ]


@contextmanager
def _ignore_errors(ignore_option_errors: bool):
    if not ignore_option_errors:
        yield
        return

    try:
        yield
    except Exception as ex:
        _logger.debug(f"ignored error: {ex.__class__.__name__} - {ex}")


class _EnsurePackagesDiscovered(_expand.EnsurePackagesDiscovered):
    def __init__(
        self, distribution: "Distribution", project_cfg: dict, setuptools_cfg: dict
    ):
        super().__init__(distribution)
        self._project_cfg = project_cfg
        self._setuptools_cfg = setuptools_cfg

    def __enter__(self):
        """When entering the context, the values of ``packages``, ``py_modules`` and
        ``package_dir`` that are missing in ``dist`` are copied from ``setuptools_cfg``.
        """
        dist, cfg = self._dist, self._setuptools_cfg
        package_dir: Dict[str, str] = cfg.setdefault("package-dir", {})
        package_dir.update(dist.package_dir or {})
        dist.package_dir = package_dir  # needs to be the same object

        dist.set_defaults._ignore_ext_modules()  # pyproject.toml-specific behaviour

        # Set `name`, `py_modules` and `packages` in dist to short-circuit
        # auto-discovery, but avoid overwriting empty lists purposefully set by users.
        if dist.metadata.name is None:
            dist.metadata.name = self._project_cfg.get("name")
        if dist.py_modules is None:
            dist.py_modules = cfg.get("py-modules")
        if dist.packages is None:
            dist.packages = cfg.get("packages")

        return super().__enter__()

    def __exit__(self, exc_type, exc_value, traceback):
        """When exiting the context, if values of ``packages``, ``py_modules`` and
        ``package_dir`` are missing in ``setuptools_cfg``, copy from ``dist``.
        """
        # If anything was discovered set them back, so they count in the final config.
        self._setuptools_cfg.setdefault("packages", self._dist.packages)
        self._setuptools_cfg.setdefault("py-modules", self._dist.py_modules)
        return super().__exit__(exc_type, exc_value, traceback)


class _ExperimentalConfiguration(SetuptoolsWarning):
    _SUMMARY = (
        "`{subject}` in `pyproject.toml` is still *experimental* "
        "and likely to change in future releases."
    )
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/config/setupcfg.py0000644000175100001730000006311014467657412021333 0ustar00runnerdocker"""
Load setuptools configuration from ``setup.cfg`` files.

**API will be made private in the future**

To read project metadata, consider using
``build.util.project_wheel_metadata`` (https://pypi.org/project/build/).
For simple scenarios, you can also try parsing the file directly
with the help of ``configparser``.
"""
import contextlib
import functools
import os
from collections import defaultdict
from functools import partial
from functools import wraps
from typing import (
    TYPE_CHECKING,
    Callable,
    Any,
    Dict,
    Generic,
    Iterable,
    List,
    Optional,
    Set,
    Tuple,
    TypeVar,
    Union,
)

from ..errors import FileError, OptionError
from ..extern.packaging.markers import default_environment as marker_env
from ..extern.packaging.requirements import InvalidRequirement, Requirement
from ..extern.packaging.specifiers import SpecifierSet
from ..extern.packaging.version import InvalidVersion, Version
from ..warnings import SetuptoolsDeprecationWarning
from . import expand

if TYPE_CHECKING:
    from distutils.dist import DistributionMetadata  # noqa

    from setuptools.dist import Distribution  # noqa

_Path = Union[str, os.PathLike]
SingleCommandOptions = Dict["str", Tuple["str", Any]]
"""Dict that associate the name of the options of a particular command to a
tuple. The first element of the tuple indicates the origin of the option value
(e.g. the name of the configuration file where it was read from),
while the second element of the tuple is the option value itself
"""
AllCommandOptions = Dict["str", SingleCommandOptions]  # cmd name => its options
Target = TypeVar("Target", bound=Union["Distribution", "DistributionMetadata"])


def read_configuration(
    filepath: _Path, find_others=False, ignore_option_errors=False
) -> dict:
    """Read given configuration file and returns options from it as a dict.

    :param str|unicode filepath: Path to configuration file
        to get options from.

    :param bool find_others: Whether to search for other configuration files
        which could be on in various places.

    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.

    :rtype: dict
    """
    from setuptools.dist import Distribution

    dist = Distribution()
    filenames = dist.find_config_files() if find_others else []
    handlers = _apply(dist, filepath, filenames, ignore_option_errors)
    return configuration_to_dict(handlers)


def apply_configuration(dist: "Distribution", filepath: _Path) -> "Distribution":
    """Apply the configuration from a ``setup.cfg`` file into an existing
    distribution object.
    """
    _apply(dist, filepath)
    dist._finalize_requires()
    return dist


def _apply(
    dist: "Distribution",
    filepath: _Path,
    other_files: Iterable[_Path] = (),
    ignore_option_errors: bool = False,
) -> Tuple["ConfigHandler", ...]:
    """Read configuration from ``filepath`` and applies to the ``dist`` object."""
    from setuptools.dist import _Distribution

    filepath = os.path.abspath(filepath)

    if not os.path.isfile(filepath):
        raise FileError(f'Configuration file {filepath} does not exist.')

    current_directory = os.getcwd()
    os.chdir(os.path.dirname(filepath))
    filenames = [*other_files, filepath]

    try:
        _Distribution.parse_config_files(dist, filenames=filenames)
        handlers = parse_configuration(
            dist, dist.command_options, ignore_option_errors=ignore_option_errors
        )
        dist._finalize_license_files()
    finally:
        os.chdir(current_directory)

    return handlers


def _get_option(target_obj: Target, key: str):
    """
    Given a target object and option key, get that option from
    the target object, either through a get_{key} method or
    from an attribute directly.
    """
    getter_name = f'get_{key}'
    by_attribute = functools.partial(getattr, target_obj, key)
    getter = getattr(target_obj, getter_name, by_attribute)
    return getter()


def configuration_to_dict(handlers: Tuple["ConfigHandler", ...]) -> dict:
    """Returns configuration data gathered by given handlers as a dict.

    :param list[ConfigHandler] handlers: Handlers list,
        usually from parse_configuration()

    :rtype: dict
    """
    config_dict: dict = defaultdict(dict)

    for handler in handlers:
        for option in handler.set_options:
            value = _get_option(handler.target_obj, option)
            config_dict[handler.section_prefix][option] = value

    return config_dict


def parse_configuration(
    distribution: "Distribution",
    command_options: AllCommandOptions,
    ignore_option_errors=False,
) -> Tuple["ConfigMetadataHandler", "ConfigOptionsHandler"]:
    """Performs additional parsing of configuration options
    for a distribution.

    Returns a list of used option handlers.

    :param Distribution distribution:
    :param dict command_options:
    :param bool ignore_option_errors: Whether to silently ignore
        options, values of which could not be resolved (e.g. due to exceptions
        in directives such as file:, attr:, etc.).
        If False exceptions are propagated as expected.
    :rtype: list
    """
    with expand.EnsurePackagesDiscovered(distribution) as ensure_discovered:
        options = ConfigOptionsHandler(
            distribution,
            command_options,
            ignore_option_errors,
            ensure_discovered,
        )

        options.parse()
        if not distribution.package_dir:
            distribution.package_dir = options.package_dir  # Filled by `find_packages`

        meta = ConfigMetadataHandler(
            distribution.metadata,
            command_options,
            ignore_option_errors,
            ensure_discovered,
            distribution.package_dir,
            distribution.src_root,
        )
        meta.parse()
        distribution._referenced_files.update(
            options._referenced_files, meta._referenced_files
        )

    return meta, options


def _warn_accidental_env_marker_misconfig(label: str, orig_value: str, parsed: list):
    """Because users sometimes misinterpret this configuration:

    [options.extras_require]
    foo = bar;python_version<"4"

    It looks like one requirement with an environment marker
    but because there is no newline, it's parsed as two requirements
    with a semicolon as separator.

    Therefore, if:
        * input string does not contain a newline AND
        * parsed result contains two requirements AND
        * parsing of the two parts from the result (";")
        leads in a valid Requirement with a valid marker
    a UserWarning is shown to inform the user about the possible problem.
    """
    if "\n" in orig_value or len(parsed) != 2:
        return

    markers = marker_env().keys()

    try:
        req = Requirement(parsed[1])
        if req.name in markers:
            _AmbiguousMarker.emit(field=label, req=parsed[1])
    except InvalidRequirement as ex:
        if any(parsed[1].startswith(marker) for marker in markers):
            msg = _AmbiguousMarker.message(field=label, req=parsed[1])
            raise InvalidRequirement(msg) from ex


class ConfigHandler(Generic[Target]):
    """Handles metadata supplied in configuration files."""

    section_prefix: str
    """Prefix for config sections handled by this handler.
    Must be provided by class heirs.

    """

    aliases: Dict[str, str] = {}
    """Options aliases.
    For compatibility with various packages. E.g.: d2to1 and pbr.
    Note: `-` in keys is replaced with `_` by config parser.

    """

    def __init__(
        self,
        target_obj: Target,
        options: AllCommandOptions,
        ignore_option_errors,
        ensure_discovered: expand.EnsurePackagesDiscovered,
    ):
        self.ignore_option_errors = ignore_option_errors
        self.target_obj = target_obj
        self.sections = dict(self._section_options(options))
        self.set_options: List[str] = []
        self.ensure_discovered = ensure_discovered
        self._referenced_files: Set[str] = set()
        """After parsing configurations, this property will enumerate
        all files referenced by the "file:" directive. Private API for setuptools only.
        """

    @classmethod
    def _section_options(cls, options: AllCommandOptions):
        for full_name, value in options.items():
            pre, sep, name = full_name.partition(cls.section_prefix)
            if pre:
                continue
            yield name.lstrip('.'), value

    @property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        raise NotImplementedError(
            '%s must provide .parsers property' % self.__class__.__name__
        )

    def __setitem__(self, option_name, value):
        target_obj = self.target_obj

        # Translate alias into real name.
        option_name = self.aliases.get(option_name, option_name)

        try:
            current_value = getattr(target_obj, option_name)
        except AttributeError:
            raise KeyError(option_name)

        if current_value:
            # Already inhabited. Skipping.
            return

        try:
            parsed = self.parsers.get(option_name, lambda x: x)(value)
        except (Exception,) * self.ignore_option_errors:
            return

        simple_setter = functools.partial(target_obj.__setattr__, option_name)
        setter = getattr(target_obj, 'set_%s' % option_name, simple_setter)
        setter(parsed)

        self.set_options.append(option_name)

    @classmethod
    def _parse_list(cls, value, separator=','):
        """Represents value as a list.

        Value is split either by separator (defaults to comma) or by lines.

        :param value:
        :param separator: List items separator character.
        :rtype: list
        """
        if isinstance(value, list):  # _get_parser_compound case
            return value

        if '\n' in value:
            value = value.splitlines()
        else:
            value = value.split(separator)

        return [chunk.strip() for chunk in value if chunk.strip()]

    @classmethod
    def _parse_dict(cls, value):
        """Represents value as a dict.

        :param value:
        :rtype: dict
        """
        separator = '='
        result = {}
        for line in cls._parse_list(value):
            key, sep, val = line.partition(separator)
            if sep != separator:
                raise OptionError(f"Unable to parse option value to dict: {value}")
            result[key.strip()] = val.strip()

        return result

    @classmethod
    def _parse_bool(cls, value):
        """Represents value as boolean.

        :param value:
        :rtype: bool
        """
        value = value.lower()
        return value in ('1', 'true', 'yes')

    @classmethod
    def _exclude_files_parser(cls, key):
        """Returns a parser function to make sure field inputs
        are not files.

        Parses a value after getting the key so error messages are
        more informative.

        :param key:
        :rtype: callable
        """

        def parser(value):
            exclude_directive = 'file:'
            if value.startswith(exclude_directive):
                raise ValueError(
                    'Only strings are accepted for the {0} field, '
                    'files are not accepted'.format(key)
                )
            return value

        return parser

    def _parse_file(self, value, root_dir: _Path):
        """Represents value as a string, allowing including text
        from nearest files using `file:` directive.

        Directive is sandboxed and won't reach anything outside
        directory with setup.py.

        Examples:
            file: README.rst, CHANGELOG.md, src/file.txt

        :param str value:
        :rtype: str
        """
        include_directive = 'file:'

        if not isinstance(value, str):
            return value

        if not value.startswith(include_directive):
            return value

        spec = value[len(include_directive) :]
        filepaths = [path.strip() for path in spec.split(',')]
        self._referenced_files.update(filepaths)
        return expand.read_files(filepaths, root_dir)

    def _parse_attr(self, value, package_dir, root_dir: _Path):
        """Represents value as a module attribute.

        Examples:
            attr: package.attr
            attr: package.module.attr

        :param str value:
        :rtype: str
        """
        attr_directive = 'attr:'
        if not value.startswith(attr_directive):
            return value

        attr_desc = value.replace(attr_directive, '')

        # Make sure package_dir is populated correctly, so `attr:` directives can work
        package_dir.update(self.ensure_discovered.package_dir)
        return expand.read_attr(attr_desc, package_dir, root_dir)

    @classmethod
    def _get_parser_compound(cls, *parse_methods):
        """Returns parser function to represents value as a list.

        Parses a value applying given methods one after another.

        :param parse_methods:
        :rtype: callable
        """

        def parse(value):
            parsed = value

            for method in parse_methods:
                parsed = method(parsed)

            return parsed

        return parse

    @classmethod
    def _parse_section_to_dict_with_key(cls, section_options, values_parser):
        """Parses section options into a dictionary.

        Applies a given parser to each option in a section.

        :param dict section_options:
        :param callable values_parser: function with 2 args corresponding to key, value
        :rtype: dict
        """
        value = {}
        for key, (_, val) in section_options.items():
            value[key] = values_parser(key, val)
        return value

    @classmethod
    def _parse_section_to_dict(cls, section_options, values_parser=None):
        """Parses section options into a dictionary.

        Optionally applies a given parser to each value.

        :param dict section_options:
        :param callable values_parser: function with 1 arg corresponding to option value
        :rtype: dict
        """
        parser = (lambda _, v: values_parser(v)) if values_parser else (lambda _, v: v)
        return cls._parse_section_to_dict_with_key(section_options, parser)

    def parse_section(self, section_options):
        """Parses configuration file section.

        :param dict section_options:
        """
        for name, (_, value) in section_options.items():
            with contextlib.suppress(KeyError):
                # Keep silent for a new option may appear anytime.
                self[name] = value

    def parse(self):
        """Parses configuration file items from one
        or more related sections.

        """
        for section_name, section_options in self.sections.items():
            method_postfix = ''
            if section_name:  # [section.option] variant
                method_postfix = '_%s' % section_name

            section_parser_method: Optional[Callable] = getattr(
                self,
                # Dots in section names are translated into dunderscores.
                ('parse_section%s' % method_postfix).replace('.', '__'),
                None,
            )

            if section_parser_method is None:
                raise OptionError(
                    "Unsupported distribution option section: "
                    f"[{self.section_prefix}.{section_name}]"
                )

            section_parser_method(section_options)

    def _deprecated_config_handler(self, func, msg, **kw):
        """this function will wrap around parameters that are deprecated

        :param msg: deprecation message
        :param func: function to be wrapped around
        """

        @wraps(func)
        def config_handler(*args, **kwargs):
            kw.setdefault("stacklevel", 2)
            _DeprecatedConfig.emit("Deprecated config in `setup.cfg`", msg, **kw)
            return func(*args, **kwargs)

        return config_handler


class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
    section_prefix = 'metadata'

    aliases = {
        'home_page': 'url',
        'summary': 'description',
        'classifier': 'classifiers',
        'platform': 'platforms',
    }

    strict_mode = False
    """We need to keep it loose, to be partially compatible with
    `pbr` and `d2to1` packages which also uses `metadata` section.

    """

    def __init__(
        self,
        target_obj: "DistributionMetadata",
        options: AllCommandOptions,
        ignore_option_errors: bool,
        ensure_discovered: expand.EnsurePackagesDiscovered,
        package_dir: Optional[dict] = None,
        root_dir: _Path = os.curdir,
    ):
        super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
        self.package_dir = package_dir
        self.root_dir = root_dir

    @property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        parse_list = self._parse_list
        parse_file = partial(self._parse_file, root_dir=self.root_dir)
        parse_dict = self._parse_dict
        exclude_files_parser = self._exclude_files_parser

        return {
            'platforms': parse_list,
            'keywords': parse_list,
            'provides': parse_list,
            'requires': self._deprecated_config_handler(
                parse_list,
                "The requires parameter is deprecated, please use "
                "install_requires for runtime dependencies.",
                due_date=(2023, 10, 30),
                # Warning introduced in 27 Oct 2018
            ),
            'obsoletes': parse_list,
            'classifiers': self._get_parser_compound(parse_file, parse_list),
            'license': exclude_files_parser('license'),
            'license_file': self._deprecated_config_handler(
                exclude_files_parser('license_file'),
                "The license_file parameter is deprecated, "
                "use license_files instead.",
                due_date=(2023, 10, 30),
                # Warning introduced in 23 May 2021
            ),
            'license_files': parse_list,
            'description': parse_file,
            'long_description': parse_file,
            'version': self._parse_version,
            'project_urls': parse_dict,
        }

    def _parse_version(self, value):
        """Parses `version` option value.

        :param value:
        :rtype: str

        """
        version = self._parse_file(value, self.root_dir)

        if version != value:
            version = version.strip()
            # Be strict about versions loaded from file because it's easy to
            # accidentally include newlines and other unintended content
            try:
                Version(version)
            except InvalidVersion:
                raise OptionError(
                    f'Version loaded from {value} does not '
                    f'comply with PEP 440: {version}'
                )

            return version

        return expand.version(self._parse_attr(value, self.package_dir, self.root_dir))


class ConfigOptionsHandler(ConfigHandler["Distribution"]):
    section_prefix = 'options'

    def __init__(
        self,
        target_obj: "Distribution",
        options: AllCommandOptions,
        ignore_option_errors: bool,
        ensure_discovered: expand.EnsurePackagesDiscovered,
    ):
        super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
        self.root_dir = target_obj.src_root
        self.package_dir: Dict[str, str] = {}  # To be filled by `find_packages`

    @classmethod
    def _parse_list_semicolon(cls, value):
        return cls._parse_list(value, separator=';')

    def _parse_file_in_root(self, value):
        return self._parse_file(value, root_dir=self.root_dir)

    def _parse_requirements_list(self, label: str, value: str):
        # Parse a requirements list, either by reading in a `file:`, or a list.
        parsed = self._parse_list_semicolon(self._parse_file_in_root(value))
        _warn_accidental_env_marker_misconfig(label, value, parsed)
        # Filter it to only include lines that are not comments. `parse_list`
        # will have stripped each line and filtered out empties.
        return [line for line in parsed if not line.startswith("#")]

    @property
    def parsers(self):
        """Metadata item name to parser function mapping."""
        parse_list = self._parse_list
        parse_bool = self._parse_bool
        parse_dict = self._parse_dict
        parse_cmdclass = self._parse_cmdclass

        return {
            'zip_safe': parse_bool,
            'include_package_data': parse_bool,
            'package_dir': parse_dict,
            'scripts': parse_list,
            'eager_resources': parse_list,
            'dependency_links': parse_list,
            'namespace_packages': self._deprecated_config_handler(
                parse_list,
                "The namespace_packages parameter is deprecated, "
                "consider using implicit namespaces instead (PEP 420).",
                # TODO: define due date, see setuptools.dist:check_nsp.
            ),
            'install_requires': partial(
                self._parse_requirements_list, "install_requires"
            ),
            'setup_requires': self._parse_list_semicolon,
            'tests_require': self._parse_list_semicolon,
            'packages': self._parse_packages,
            'entry_points': self._parse_file_in_root,
            'py_modules': parse_list,
            'python_requires': SpecifierSet,
            'cmdclass': parse_cmdclass,
        }

    def _parse_cmdclass(self, value):
        package_dir = self.ensure_discovered.package_dir
        return expand.cmdclass(self._parse_dict(value), package_dir, self.root_dir)

    def _parse_packages(self, value):
        """Parses `packages` option value.

        :param value:
        :rtype: list
        """
        find_directives = ['find:', 'find_namespace:']
        trimmed_value = value.strip()

        if trimmed_value not in find_directives:
            return self._parse_list(value)

        # Read function arguments from a dedicated section.
        find_kwargs = self.parse_section_packages__find(
            self.sections.get('packages.find', {})
        )

        find_kwargs.update(
            namespaces=(trimmed_value == find_directives[1]),
            root_dir=self.root_dir,
            fill_package_dir=self.package_dir,
        )

        return expand.find_packages(**find_kwargs)

    def parse_section_packages__find(self, section_options):
        """Parses `packages.find` configuration file section.

        To be used in conjunction with _parse_packages().

        :param dict section_options:
        """
        section_data = self._parse_section_to_dict(section_options, self._parse_list)

        valid_keys = ['where', 'include', 'exclude']

        find_kwargs = dict(
            [(k, v) for k, v in section_data.items() if k in valid_keys and v]
        )

        where = find_kwargs.get('where')
        if where is not None:
            find_kwargs['where'] = where[0]  # cast list to single val

        return find_kwargs

    def parse_section_entry_points(self, section_options):
        """Parses `entry_points` configuration file section.

        :param dict section_options:
        """
        parsed = self._parse_section_to_dict(section_options, self._parse_list)
        self['entry_points'] = parsed

    def _parse_package_data(self, section_options):
        package_data = self._parse_section_to_dict(section_options, self._parse_list)
        return expand.canonic_package_data(package_data)

    def parse_section_package_data(self, section_options):
        """Parses `package_data` configuration file section.

        :param dict section_options:
        """
        self['package_data'] = self._parse_package_data(section_options)

    def parse_section_exclude_package_data(self, section_options):
        """Parses `exclude_package_data` configuration file section.

        :param dict section_options:
        """
        self['exclude_package_data'] = self._parse_package_data(section_options)

    def parse_section_extras_require(self, section_options):
        """Parses `extras_require` configuration file section.

        :param dict section_options:
        """
        parsed = self._parse_section_to_dict_with_key(
            section_options,
            lambda k, v: self._parse_requirements_list(f"extras_require[{k}]", v),
        )

        self['extras_require'] = parsed

    def parse_section_data_files(self, section_options):
        """Parses `data_files` configuration file section.

        :param dict section_options:
        """
        parsed = self._parse_section_to_dict(section_options, self._parse_list)
        self['data_files'] = expand.canonic_data_files(parsed, self.root_dir)


class _AmbiguousMarker(SetuptoolsDeprecationWarning):
    _SUMMARY = "Ambiguous requirement marker."
    _DETAILS = """
    One of the parsed requirements in `{field}` looks like a valid environment marker:

        {req!r}

    Please make sure that the configuration file is correct.
    You can use dangling lines to avoid this problem.
    """
    _SEE_DOCS = "userguide/declarative_config.html#opt-2"
    # TODO: should we include due_date here? Initially introduced in 6 Aug 2022.
    # Does this make sense with latest version of packaging?

    @classmethod
    def message(cls, **kw):
        docs = f"https://setuptools.pypa.io/en/latest/{cls._SEE_DOCS}"
        return cls._format(cls._SUMMARY, cls._DETAILS, see_url=docs, format_args=kw)


class _DeprecatedConfig(SetuptoolsDeprecationWarning):
    _SEE_DOCS = "userguide/declarative_config.html"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/dep_util.py0000644000175100001730000000165014467657412020054 0ustar00runnerdockerfrom distutils.dep_util import newer_group


# yes, this is was almost entirely copy-pasted from
# 'newer_pairwise()', this is just another convenience
# function.
def newer_pairwise_group(sources_groups, targets):
    """Walk both arguments in parallel, testing if each source group is newer
    than its corresponding target. Returns a pair of lists (sources_groups,
    targets) where sources is newer than target, according to the semantics
    of 'newer_group()'.
    """
    if len(sources_groups) != len(targets):
        raise ValueError("'sources_group' and 'targets' must be the same length")

    # build a pair of lists (sources_groups, targets) where source is newer
    n_sources = []
    n_targets = []
    for i in range(len(sources_groups)):
        if newer_group(sources_groups[i], targets[i]):
            n_sources.append(sources_groups[i])
            n_targets.append(targets[i])

    return n_sources, n_targets
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/depends.py0000644000175100001730000001263014467657412017671 0ustar00runnerdockerimport sys
import marshal
import contextlib
import dis

from setuptools.extern.packaging import version

from ._imp import find_module, PY_COMPILED, PY_FROZEN, PY_SOURCE
from . import _imp


__all__ = ['Require', 'find_module', 'get_module_constant', 'extract_constant']


class Require:
    """A prerequisite to building or installing a distribution"""

    def __init__(
        self, name, requested_version, module, homepage='', attribute=None, format=None
    ):
        if format is None and requested_version is not None:
            format = version.Version

        if format is not None:
            requested_version = format(requested_version)
            if attribute is None:
                attribute = '__version__'

        self.__dict__.update(locals())
        del self.self

    def full_name(self):
        """Return full package/distribution name, w/version"""
        if self.requested_version is not None:
            return '%s-%s' % (self.name, self.requested_version)
        return self.name

    def version_ok(self, version):
        """Is 'version' sufficiently up-to-date?"""
        return (
            self.attribute is None
            or self.format is None
            or str(version) != "unknown"
            and self.format(version) >= self.requested_version
        )

    def get_version(self, paths=None, default="unknown"):
        """Get version number of installed module, 'None', or 'default'

        Search 'paths' for module.  If not found, return 'None'.  If found,
        return the extracted version attribute, or 'default' if no version
        attribute was specified, or the value cannot be determined without
        importing the module.  The version is formatted according to the
        requirement's version format (if any), unless it is 'None' or the
        supplied 'default'.
        """

        if self.attribute is None:
            try:
                f, p, i = find_module(self.module, paths)
                if f:
                    f.close()
                return default
            except ImportError:
                return None

        v = get_module_constant(self.module, self.attribute, default, paths)

        if v is not None and v is not default and self.format is not None:
            return self.format(v)

        return v

    def is_present(self, paths=None):
        """Return true if dependency is present on 'paths'"""
        return self.get_version(paths) is not None

    def is_current(self, paths=None):
        """Return true if dependency is present and up-to-date on 'paths'"""
        version = self.get_version(paths)
        if version is None:
            return False
        return self.version_ok(str(version))


def maybe_close(f):
    @contextlib.contextmanager
    def empty():
        yield
        return

    if not f:
        return empty()

    return contextlib.closing(f)


def get_module_constant(module, symbol, default=-1, paths=None):
    """Find 'module' by searching 'paths', and extract 'symbol'

    Return 'None' if 'module' does not exist on 'paths', or it does not define
    'symbol'.  If the module defines 'symbol' as a constant, return the
    constant.  Otherwise, return 'default'."""

    try:
        f, path, (suffix, mode, kind) = info = find_module(module, paths)
    except ImportError:
        # Module doesn't exist
        return None

    with maybe_close(f):
        if kind == PY_COMPILED:
            f.read(8)  # skip magic & date
            code = marshal.load(f)
        elif kind == PY_FROZEN:
            code = _imp.get_frozen_object(module, paths)
        elif kind == PY_SOURCE:
            code = compile(f.read(), path, 'exec')
        else:
            # Not something we can parse; we'll have to import it.  :(
            imported = _imp.get_module(module, paths, info)
            return getattr(imported, symbol, None)

    return extract_constant(code, symbol, default)


def extract_constant(code, symbol, default=-1):
    """Extract the constant value of 'symbol' from 'code'

    If the name 'symbol' is bound to a constant value by the Python code
    object 'code', return that value.  If 'symbol' is bound to an expression,
    return 'default'.  Otherwise, return 'None'.

    Return value is based on the first assignment to 'symbol'.  'symbol' must
    be a global, or at least a non-"fast" local in the code block.  That is,
    only 'STORE_NAME' and 'STORE_GLOBAL' opcodes are checked, and 'symbol'
    must be present in 'code.co_names'.
    """
    if symbol not in code.co_names:
        # name's not there, can't possibly be an assignment
        return None

    name_idx = list(code.co_names).index(symbol)

    STORE_NAME = 90
    STORE_GLOBAL = 97
    LOAD_CONST = 100

    const = default

    for byte_code in dis.Bytecode(code):
        op = byte_code.opcode
        arg = byte_code.arg

        if op == LOAD_CONST:
            const = code.co_consts[arg]
        elif arg == name_idx and (op == STORE_NAME or op == STORE_GLOBAL):
            return const
        else:
            const = default


def _update_globals():
    """
    Patch the globals to remove the objects not available on some platforms.

    XXX it'd be better to test assertions about bytecode instead.
    """

    if not sys.platform.startswith('java') and sys.platform != 'cli':
        return
    incompatible = 'extract_constant', 'get_module_constant'
    for name in incompatible:
        del globals()[name]
        __all__.remove(name)


_update_globals()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/discovery.py0000644000175100001730000005123314467657412020260 0ustar00runnerdocker"""Automatic discovery of Python modules and packages (for inclusion in the
distribution) and other config values.

For the purposes of this module, the following nomenclature is used:

- "src-layout": a directory representing a Python project that contains a "src"
  folder. Everything under the "src" folder is meant to be included in the
  distribution when packaging the project. Example::

    .
    ├── tox.ini
    ├── pyproject.toml
    └── src/
        └── mypkg/
            ├── __init__.py
            ├── mymodule.py
            └── my_data_file.txt

- "flat-layout": a Python project that does not use "src-layout" but instead
  have a directory under the project root for each package::

    .
    ├── tox.ini
    ├── pyproject.toml
    └── mypkg/
        ├── __init__.py
        ├── mymodule.py
        └── my_data_file.txt

- "single-module": a project that contains a single Python script direct under
  the project root (no directory used)::

    .
    ├── tox.ini
    ├── pyproject.toml
    └── mymodule.py

"""

import itertools
import os
from fnmatch import fnmatchcase
from glob import glob
from pathlib import Path
from typing import (
    TYPE_CHECKING,
    Dict,
    Iterable,
    Iterator,
    List,
    Mapping,
    Optional,
    Tuple,
    Union,
)

import _distutils_hack.override  # noqa: F401

from distutils import log
from distutils.util import convert_path

_Path = Union[str, os.PathLike]
StrIter = Iterator[str]

chain_iter = itertools.chain.from_iterable

if TYPE_CHECKING:
    from setuptools import Distribution  # noqa


def _valid_name(path: _Path) -> bool:
    # Ignore invalid names that cannot be imported directly
    return os.path.basename(path).isidentifier()


class _Filter:
    """
    Given a list of patterns, create a callable that will be true only if
    the input matches at least one of the patterns.
    """

    def __init__(self, *patterns: str):
        self._patterns = dict.fromkeys(patterns)

    def __call__(self, item: str) -> bool:
        return any(fnmatchcase(item, pat) for pat in self._patterns)

    def __contains__(self, item: str) -> bool:
        return item in self._patterns


class _Finder:
    """Base class that exposes functionality for module/package finders"""

    ALWAYS_EXCLUDE: Tuple[str, ...] = ()
    DEFAULT_EXCLUDE: Tuple[str, ...] = ()

    @classmethod
    def find(
        cls,
        where: _Path = '.',
        exclude: Iterable[str] = (),
        include: Iterable[str] = ('*',),
    ) -> List[str]:
        """Return a list of all Python items (packages or modules, depending on
        the finder implementation) found within directory 'where'.

        'where' is the root directory which will be searched.
        It should be supplied as a "cross-platform" (i.e. URL-style) path;
        it will be converted to the appropriate local path syntax.

        'exclude' is a sequence of names to exclude; '*' can be used
        as a wildcard in the names.
        When finding packages, 'foo.*' will exclude all subpackages of 'foo'
        (but not 'foo' itself).

        'include' is a sequence of names to include.
        If it's specified, only the named items will be included.
        If it's not specified, all found items will be included.
        'include' can contain shell style wildcard patterns just like
        'exclude'.
        """

        exclude = exclude or cls.DEFAULT_EXCLUDE
        return list(
            cls._find_iter(
                convert_path(str(where)),
                _Filter(*cls.ALWAYS_EXCLUDE, *exclude),
                _Filter(*include),
            )
        )

    @classmethod
    def _find_iter(cls, where: _Path, exclude: _Filter, include: _Filter) -> StrIter:
        raise NotImplementedError


class PackageFinder(_Finder):
    """
    Generate a list of all Python packages found within a directory
    """

    ALWAYS_EXCLUDE = ("ez_setup", "*__pycache__")

    @classmethod
    def _find_iter(cls, where: _Path, exclude: _Filter, include: _Filter) -> StrIter:
        """
        All the packages found in 'where' that pass the 'include' filter, but
        not the 'exclude' filter.
        """
        for root, dirs, files in os.walk(str(where), followlinks=True):
            # Copy dirs to iterate over it, then empty dirs.
            all_dirs = dirs[:]
            dirs[:] = []

            for dir in all_dirs:
                full_path = os.path.join(root, dir)
                rel_path = os.path.relpath(full_path, where)
                package = rel_path.replace(os.path.sep, '.')

                # Skip directory trees that are not valid packages
                if '.' in dir or not cls._looks_like_package(full_path, package):
                    continue

                # Should this package be included?
                if include(package) and not exclude(package):
                    yield package

                # Early pruning if there is nothing else to be scanned
                if f"{package}*" in exclude or f"{package}.*" in exclude:
                    continue

                # Keep searching subdirectories, as there may be more packages
                # down there, even if the parent was excluded.
                dirs.append(dir)

    @staticmethod
    def _looks_like_package(path: _Path, _package_name: str) -> bool:
        """Does a directory look like a package?"""
        return os.path.isfile(os.path.join(path, '__init__.py'))


class PEP420PackageFinder(PackageFinder):
    @staticmethod
    def _looks_like_package(_path: _Path, _package_name: str) -> bool:
        return True


class ModuleFinder(_Finder):
    """Find isolated Python modules.
    This function will **not** recurse subdirectories.
    """

    @classmethod
    def _find_iter(cls, where: _Path, exclude: _Filter, include: _Filter) -> StrIter:
        for file in glob(os.path.join(where, "*.py")):
            module, _ext = os.path.splitext(os.path.basename(file))

            if not cls._looks_like_module(module):
                continue

            if include(module) and not exclude(module):
                yield module

    _looks_like_module = staticmethod(_valid_name)


# We have to be extra careful in the case of flat layout to not include files
# and directories not meant for distribution (e.g. tool-related)


class FlatLayoutPackageFinder(PEP420PackageFinder):
    _EXCLUDE = (
        "ci",
        "bin",
        "debian",
        "doc",
        "docs",
        "documentation",
        "manpages",
        "news",
        "newsfragments",
        "changelog",
        "test",
        "tests",
        "unit_test",
        "unit_tests",
        "example",
        "examples",
        "scripts",
        "tools",
        "util",
        "utils",
        "python",
        "build",
        "dist",
        "venv",
        "env",
        "requirements",
        # ---- Task runners / Build tools ----
        "tasks",  # invoke
        "fabfile",  # fabric
        "site_scons",  # SCons
        # ---- Other tools ----
        "benchmark",
        "benchmarks",
        "exercise",
        "exercises",
        "htmlcov",  # Coverage.py
        # ---- Hidden directories/Private packages ----
        "[._]*",
    )

    DEFAULT_EXCLUDE = tuple(chain_iter((p, f"{p}.*") for p in _EXCLUDE))
    """Reserved package names"""

    @staticmethod
    def _looks_like_package(_path: _Path, package_name: str) -> bool:
        names = package_name.split('.')
        # Consider PEP 561
        root_pkg_is_valid = names[0].isidentifier() or names[0].endswith("-stubs")
        return root_pkg_is_valid and all(name.isidentifier() for name in names[1:])


class FlatLayoutModuleFinder(ModuleFinder):
    DEFAULT_EXCLUDE = (
        "setup",
        "conftest",
        "test",
        "tests",
        "example",
        "examples",
        "build",
        # ---- Task runners ----
        "toxfile",
        "noxfile",
        "pavement",
        "dodo",
        "tasks",
        "fabfile",
        # ---- Other tools ----
        "[Ss][Cc]onstruct",  # SCons
        "conanfile",  # Connan: C/C++ build tool
        "manage",  # Django
        "benchmark",
        "benchmarks",
        "exercise",
        "exercises",
        # ---- Hidden files/Private modules ----
        "[._]*",
    )
    """Reserved top-level module names"""


def _find_packages_within(root_pkg: str, pkg_dir: _Path) -> List[str]:
    nested = PEP420PackageFinder.find(pkg_dir)
    return [root_pkg] + [".".join((root_pkg, n)) for n in nested]


class ConfigDiscovery:
    """Fill-in metadata and options that can be automatically derived
    (from other metadata/options, the file system or conventions)
    """

    def __init__(self, distribution: "Distribution"):
        self.dist = distribution
        self._called = False
        self._disabled = False
        self._skip_ext_modules = False

    def _disable(self):
        """Internal API to disable automatic discovery"""
        self._disabled = True

    def _ignore_ext_modules(self):
        """Internal API to disregard ext_modules.

        Normally auto-discovery would not be triggered if ``ext_modules`` are set
        (this is done for backward compatibility with existing packages relying on
        ``setup.py`` or ``setup.cfg``). However, ``setuptools`` can call this function
        to ignore given ``ext_modules`` and proceed with the auto-discovery if
        ``packages`` and ``py_modules`` are not given (e.g. when using pyproject.toml
        metadata).
        """
        self._skip_ext_modules = True

    @property
    def _root_dir(self) -> _Path:
        # The best is to wait until `src_root` is set in dist, before using _root_dir.
        return self.dist.src_root or os.curdir

    @property
    def _package_dir(self) -> Dict[str, str]:
        if self.dist.package_dir is None:
            return {}
        return self.dist.package_dir

    def __call__(self, force=False, name=True, ignore_ext_modules=False):
        """Automatically discover missing configuration fields
        and modifies the given ``distribution`` object in-place.

        Note that by default this will only have an effect the first time the
        ``ConfigDiscovery`` object is called.

        To repeatedly invoke automatic discovery (e.g. when the project
        directory changes), please use ``force=True`` (or create a new
        ``ConfigDiscovery`` instance).
        """
        if force is False and (self._called or self._disabled):
            # Avoid overhead of multiple calls
            return

        self._analyse_package_layout(ignore_ext_modules)
        if name:
            self.analyse_name()  # depends on ``packages`` and ``py_modules``

        self._called = True

    def _explicitly_specified(self, ignore_ext_modules: bool) -> bool:
        """``True`` if the user has specified some form of package/module listing"""
        ignore_ext_modules = ignore_ext_modules or self._skip_ext_modules
        ext_modules = not (self.dist.ext_modules is None or ignore_ext_modules)
        return (
            self.dist.packages is not None
            or self.dist.py_modules is not None
            or ext_modules
            or hasattr(self.dist, "configuration")
            and self.dist.configuration
            # ^ Some projects use numpy.distutils.misc_util.Configuration
        )

    def _analyse_package_layout(self, ignore_ext_modules: bool) -> bool:
        if self._explicitly_specified(ignore_ext_modules):
            # For backward compatibility, just try to find modules/packages
            # when nothing is given
            return True

        log.debug(
            "No `packages` or `py_modules` configuration, performing "
            "automatic discovery."
        )

        return (
            self._analyse_explicit_layout()
            or self._analyse_src_layout()
            # flat-layout is the trickiest for discovery so it should be last
            or self._analyse_flat_layout()
        )

    def _analyse_explicit_layout(self) -> bool:
        """The user can explicitly give a package layout via ``package_dir``"""
        package_dir = self._package_dir.copy()  # don't modify directly
        package_dir.pop("", None)  # This falls under the "src-layout" umbrella
        root_dir = self._root_dir

        if not package_dir:
            return False

        log.debug(f"`explicit-layout` detected -- analysing {package_dir}")
        pkgs = chain_iter(
            _find_packages_within(pkg, os.path.join(root_dir, parent_dir))
            for pkg, parent_dir in package_dir.items()
        )
        self.dist.packages = list(pkgs)
        log.debug(f"discovered packages -- {self.dist.packages}")
        return True

    def _analyse_src_layout(self) -> bool:
        """Try to find all packages or modules under the ``src`` directory
        (or anything pointed by ``package_dir[""]``).

        The "src-layout" is relatively safe for automatic discovery.
        We assume that everything within is meant to be included in the
        distribution.

        If ``package_dir[""]`` is not given, but the ``src`` directory exists,
        this function will set ``package_dir[""] = "src"``.
        """
        package_dir = self._package_dir
        src_dir = os.path.join(self._root_dir, package_dir.get("", "src"))
        if not os.path.isdir(src_dir):
            return False

        log.debug(f"`src-layout` detected -- analysing {src_dir}")
        package_dir.setdefault("", os.path.basename(src_dir))
        self.dist.package_dir = package_dir  # persist eventual modifications
        self.dist.packages = PEP420PackageFinder.find(src_dir)
        self.dist.py_modules = ModuleFinder.find(src_dir)
        log.debug(f"discovered packages -- {self.dist.packages}")
        log.debug(f"discovered py_modules -- {self.dist.py_modules}")
        return True

    def _analyse_flat_layout(self) -> bool:
        """Try to find all packages and modules under the project root.

        Since the ``flat-layout`` is more dangerous in terms of accidentally including
        extra files/directories, this function is more conservative and will raise an
        error if multiple packages or modules are found.

        This assumes that multi-package dists are uncommon and refuse to support that
        use case in order to be able to prevent unintended errors.
        """
        log.debug(f"`flat-layout` detected -- analysing {self._root_dir}")
        return self._analyse_flat_packages() or self._analyse_flat_modules()

    def _analyse_flat_packages(self) -> bool:
        self.dist.packages = FlatLayoutPackageFinder.find(self._root_dir)
        top_level = remove_nested_packages(remove_stubs(self.dist.packages))
        log.debug(f"discovered packages -- {self.dist.packages}")
        self._ensure_no_accidental_inclusion(top_level, "packages")
        return bool(top_level)

    def _analyse_flat_modules(self) -> bool:
        self.dist.py_modules = FlatLayoutModuleFinder.find(self._root_dir)
        log.debug(f"discovered py_modules -- {self.dist.py_modules}")
        self._ensure_no_accidental_inclusion(self.dist.py_modules, "modules")
        return bool(self.dist.py_modules)

    def _ensure_no_accidental_inclusion(self, detected: List[str], kind: str):
        if len(detected) > 1:
            from inspect import cleandoc

            from setuptools.errors import PackageDiscoveryError

            msg = f"""Multiple top-level {kind} discovered in a flat-layout: {detected}.

            To avoid accidental inclusion of unwanted files or directories,
            setuptools will not proceed with this build.

            If you are trying to create a single distribution with multiple {kind}
            on purpose, you should not rely on automatic discovery.
            Instead, consider the following options:

            1. set up custom discovery (`find` directive with `include` or `exclude`)
            2. use a `src-layout`
            3. explicitly set `py_modules` or `packages` with a list of names

            To find more information, look for "package discovery" on setuptools docs.
            """
            raise PackageDiscoveryError(cleandoc(msg))

    def analyse_name(self):
        """The packages/modules are the essential contribution of the author.
        Therefore the name of the distribution can be derived from them.
        """
        if self.dist.metadata.name or self.dist.name:
            # get_name() is not reliable (can return "UNKNOWN")
            return None

        log.debug("No `name` configuration, performing automatic discovery")

        name = (
            self._find_name_single_package_or_module()
            or self._find_name_from_packages()
        )
        if name:
            self.dist.metadata.name = name

    def _find_name_single_package_or_module(self) -> Optional[str]:
        """Exactly one module or package"""
        for field in ('packages', 'py_modules'):
            items = getattr(self.dist, field, None) or []
            if items and len(items) == 1:
                log.debug(f"Single module/package detected, name: {items[0]}")
                return items[0]

        return None

    def _find_name_from_packages(self) -> Optional[str]:
        """Try to find the root package that is not a PEP 420 namespace"""
        if not self.dist.packages:
            return None

        packages = remove_stubs(sorted(self.dist.packages, key=len))
        package_dir = self.dist.package_dir or {}

        parent_pkg = find_parent_package(packages, package_dir, self._root_dir)
        if parent_pkg:
            log.debug(f"Common parent package detected, name: {parent_pkg}")
            return parent_pkg

        log.warn("No parent package detected, impossible to derive `name`")
        return None


def remove_nested_packages(packages: List[str]) -> List[str]:
    """Remove nested packages from a list of packages.

    >>> remove_nested_packages(["a", "a.b1", "a.b2", "a.b1.c1"])
    ['a']
    >>> remove_nested_packages(["a", "b", "c.d", "c.d.e.f", "g.h", "a.a1"])
    ['a', 'b', 'c.d', 'g.h']
    """
    pkgs = sorted(packages, key=len)
    top_level = pkgs[:]
    size = len(pkgs)
    for i, name in enumerate(reversed(pkgs)):
        if any(name.startswith(f"{other}.") for other in top_level):
            top_level.pop(size - i - 1)

    return top_level


def remove_stubs(packages: List[str]) -> List[str]:
    """Remove type stubs (:pep:`561`) from a list of packages.

    >>> remove_stubs(["a", "a.b", "a-stubs", "a-stubs.b.c", "b", "c-stubs"])
    ['a', 'a.b', 'b']
    """
    return [pkg for pkg in packages if not pkg.split(".")[0].endswith("-stubs")]


def find_parent_package(
    packages: List[str], package_dir: Mapping[str, str], root_dir: _Path
) -> Optional[str]:
    """Find the parent package that is not a namespace."""
    packages = sorted(packages, key=len)
    common_ancestors = []
    for i, name in enumerate(packages):
        if not all(n.startswith(f"{name}.") for n in packages[i + 1 :]):
            # Since packages are sorted by length, this condition is able
            # to find a list of all common ancestors.
            # When there is divergence (e.g. multiple root packages)
            # the list will be empty
            break
        common_ancestors.append(name)

    for name in common_ancestors:
        pkg_path = find_package_path(name, package_dir, root_dir)
        init = os.path.join(pkg_path, "__init__.py")
        if os.path.isfile(init):
            return name

    return None


def find_package_path(
    name: str, package_dir: Mapping[str, str], root_dir: _Path
) -> str:
    """Given a package name, return the path where it should be found on
    disk, considering the ``package_dir`` option.

    >>> path = find_package_path("my.pkg", {"": "root/is/nested"}, ".")
    >>> path.replace(os.sep, "/")
    './root/is/nested/my/pkg'

    >>> path = find_package_path("my.pkg", {"my": "root/is/nested"}, ".")
    >>> path.replace(os.sep, "/")
    './root/is/nested/pkg'

    >>> path = find_package_path("my.pkg", {"my.pkg": "root/is/nested"}, ".")
    >>> path.replace(os.sep, "/")
    './root/is/nested'

    >>> path = find_package_path("other.pkg", {"my.pkg": "root/is/nested"}, ".")
    >>> path.replace(os.sep, "/")
    './other/pkg'
    """
    parts = name.split(".")
    for i in range(len(parts), 0, -1):
        # Look backwards, the most specific package_dir first
        partial_name = ".".join(parts[:i])
        if partial_name in package_dir:
            parent = package_dir[partial_name]
            return os.path.join(root_dir, parent, *parts[i:])

    parent = package_dir.get("") or ""
    return os.path.join(root_dir, *parent.split("/"), *parts)


def construct_package_dir(packages: List[str], package_path: _Path) -> Dict[str, str]:
    parent_pkgs = remove_nested_packages(packages)
    prefix = Path(package_path).parts
    return {pkg: "/".join([*prefix, *pkg.split(".")]) for pkg in parent_pkgs}
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/dist.py0000644000175100001730000013335114467657412017216 0ustar00runnerdocker__all__ = ['Distribution']

import io
import sys
import re
import os
import numbers
import distutils.log
import distutils.core
import distutils.cmd
import distutils.dist
import distutils.command
from distutils.util import strtobool
from distutils.debug import DEBUG
from distutils.fancy_getopt import translate_longopt
from glob import iglob
import itertools
import textwrap
from contextlib import suppress
from typing import List, Optional, Set, TYPE_CHECKING
from pathlib import Path

from collections import defaultdict
from email import message_from_file

from distutils.errors import DistutilsOptionError, DistutilsSetupError
from distutils.util import rfc822_escape

from setuptools.extern import packaging
from setuptools.extern import ordered_set
from setuptools.extern.more_itertools import unique_everseen, partition

import setuptools
import setuptools.command
from setuptools import windows_support
from setuptools.monkey import get_unpatched
from setuptools.config import setupcfg, pyprojecttoml
from setuptools.discovery import ConfigDiscovery

from setuptools.extern.packaging import version
from . import _reqs
from . import _entry_points
from . import _normalization
from ._importlib import metadata
from .warnings import InformationOnly, SetuptoolsDeprecationWarning

if TYPE_CHECKING:
    from email.message import Message

__import__('setuptools.extern.packaging.specifiers')
__import__('setuptools.extern.packaging.version')


def get_metadata_version(self):
    mv = getattr(self, 'metadata_version', None)
    if mv is None:
        mv = version.Version('2.1')
        self.metadata_version = mv
    return mv


def rfc822_unescape(content: str) -> str:
    """Reverse RFC-822 escaping by removing leading whitespaces from content."""
    lines = content.splitlines()
    if len(lines) == 1:
        return lines[0].lstrip()
    return '\n'.join((lines[0].lstrip(), textwrap.dedent('\n'.join(lines[1:]))))


def _read_field_from_msg(msg: "Message", field: str) -> Optional[str]:
    """Read Message header field."""
    value = msg[field]
    if value == 'UNKNOWN':
        return None
    return value


def _read_field_unescaped_from_msg(msg: "Message", field: str) -> Optional[str]:
    """Read Message header field and apply rfc822_unescape."""
    value = _read_field_from_msg(msg, field)
    if value is None:
        return value
    return rfc822_unescape(value)


def _read_list_from_msg(msg: "Message", field: str) -> Optional[List[str]]:
    """Read Message header field and return all results as list."""
    values = msg.get_all(field, None)
    if values == []:
        return None
    return values


def _read_payload_from_msg(msg: "Message") -> Optional[str]:
    value = msg.get_payload().strip()
    if value == 'UNKNOWN' or not value:
        return None
    return value


def read_pkg_file(self, file):
    """Reads the metadata values from a file object."""
    msg = message_from_file(file)

    self.metadata_version = version.Version(msg['metadata-version'])
    self.name = _read_field_from_msg(msg, 'name')
    self.version = _read_field_from_msg(msg, 'version')
    self.description = _read_field_from_msg(msg, 'summary')
    # we are filling author only.
    self.author = _read_field_from_msg(msg, 'author')
    self.maintainer = None
    self.author_email = _read_field_from_msg(msg, 'author-email')
    self.maintainer_email = None
    self.url = _read_field_from_msg(msg, 'home-page')
    self.download_url = _read_field_from_msg(msg, 'download-url')
    self.license = _read_field_unescaped_from_msg(msg, 'license')

    self.long_description = _read_field_unescaped_from_msg(msg, 'description')
    if self.long_description is None and self.metadata_version >= version.Version(
        '2.1'
    ):
        self.long_description = _read_payload_from_msg(msg)
    self.description = _read_field_from_msg(msg, 'summary')

    if 'keywords' in msg:
        self.keywords = _read_field_from_msg(msg, 'keywords').split(',')

    self.platforms = _read_list_from_msg(msg, 'platform')
    self.classifiers = _read_list_from_msg(msg, 'classifier')

    # PEP 314 - these fields only exist in 1.1
    if self.metadata_version == version.Version('1.1'):
        self.requires = _read_list_from_msg(msg, 'requires')
        self.provides = _read_list_from_msg(msg, 'provides')
        self.obsoletes = _read_list_from_msg(msg, 'obsoletes')
    else:
        self.requires = None
        self.provides = None
        self.obsoletes = None

    self.license_files = _read_list_from_msg(msg, 'license-file')


def single_line(val):
    """
    Quick and dirty validation for Summary pypa/setuptools#1390.
    """
    if '\n' in val:
        # TODO: Replace with `raise ValueError("newlines not allowed")`
        # after reviewing #2893.
        msg = "newlines are not allowed in `summary` and will break in the future"
        SetuptoolsDeprecationWarning.emit("Invalid config.", msg)
        # due_date is undefined. Controversial change, there was a lot of push back.
        val = val.strip().split('\n')[0]
    return val


# Based on Python 3.5 version
def write_pkg_file(self, file):  # noqa: C901  # is too complex (14)  # FIXME
    """Write the PKG-INFO format data to a file object."""
    version = self.get_metadata_version()

    def write_field(key, value):
        file.write("%s: %s\n" % (key, value))

    write_field('Metadata-Version', str(version))
    write_field('Name', self.get_name())
    write_field('Version', self.get_version())

    summary = self.get_description()
    if summary:
        write_field('Summary', single_line(summary))

    optional_fields = (
        ('Home-page', 'url'),
        ('Download-URL', 'download_url'),
        ('Author', 'author'),
        ('Author-email', 'author_email'),
        ('Maintainer', 'maintainer'),
        ('Maintainer-email', 'maintainer_email'),
    )

    for field, attr in optional_fields:
        attr_val = getattr(self, attr, None)
        if attr_val is not None:
            write_field(field, attr_val)

    license = self.get_license()
    if license:
        write_field('License', rfc822_escape(license))

    for project_url in self.project_urls.items():
        write_field('Project-URL', '%s, %s' % project_url)

    keywords = ','.join(self.get_keywords())
    if keywords:
        write_field('Keywords', keywords)

    platforms = self.get_platforms() or []
    for platform in platforms:
        write_field('Platform', platform)

    self._write_list(file, 'Classifier', self.get_classifiers())

    # PEP 314
    self._write_list(file, 'Requires', self.get_requires())
    self._write_list(file, 'Provides', self.get_provides())
    self._write_list(file, 'Obsoletes', self.get_obsoletes())

    # Setuptools specific for PEP 345
    if hasattr(self, 'python_requires'):
        write_field('Requires-Python', self.python_requires)

    # PEP 566
    if self.long_description_content_type:
        write_field('Description-Content-Type', self.long_description_content_type)
    if self.provides_extras:
        for extra in self.provides_extras:
            write_field('Provides-Extra', extra)

    self._write_list(file, 'License-File', self.license_files or [])

    long_description = self.get_long_description()
    if long_description:
        file.write("\n%s" % long_description)
        if not long_description.endswith("\n"):
            file.write("\n")


sequence = tuple, list


def check_importable(dist, attr, value):
    try:
        ep = metadata.EntryPoint(value=value, name=None, group=None)
        assert not ep.extras
    except (TypeError, ValueError, AttributeError, AssertionError) as e:
        raise DistutilsSetupError(
            "%r must be importable 'module:attrs' string (got %r)" % (attr, value)
        ) from e


def assert_string_list(dist, attr, value):
    """Verify that value is a string list"""
    try:
        # verify that value is a list or tuple to exclude unordered
        # or single-use iterables
        assert isinstance(value, (list, tuple))
        # verify that elements of value are strings
        assert ''.join(value) != value
    except (TypeError, ValueError, AttributeError, AssertionError) as e:
        raise DistutilsSetupError(
            "%r must be a list of strings (got %r)" % (attr, value)
        ) from e


def check_nsp(dist, attr, value):
    """Verify that namespace packages are valid"""
    ns_packages = value
    assert_string_list(dist, attr, ns_packages)
    for nsp in ns_packages:
        if not dist.has_contents_for(nsp):
            raise DistutilsSetupError(
                "Distribution contains no modules or packages for "
                + "namespace package %r" % nsp
            )
        parent, sep, child = nsp.rpartition('.')
        if parent and parent not in ns_packages:
            distutils.log.warn(
                "WARNING: %r is declared as a package namespace, but %r"
                " is not: please correct this in setup.py",
                nsp,
                parent,
            )
        SetuptoolsDeprecationWarning.emit(
            "The namespace_packages parameter is deprecated.",
            "Please replace its usage with implicit namespaces (PEP 420).",
            see_docs="references/keywords.html#keyword-namespace-packages"
            # TODO: define due_date, it may break old packages that are no longer
            # maintained (e.g. sphinxcontrib extensions) when installed from source.
            # Warning officially introduced in May 2022, however the deprecation
            # was mentioned much earlier in the docs (May 2020, see #2149).
        )


def check_extras(dist, attr, value):
    """Verify that extras_require mapping is valid"""
    try:
        list(itertools.starmap(_check_extra, value.items()))
    except (TypeError, ValueError, AttributeError) as e:
        raise DistutilsSetupError(
            "'extras_require' must be a dictionary whose values are "
            "strings or lists of strings containing valid project/version "
            "requirement specifiers."
        ) from e


def _check_extra(extra, reqs):
    name, sep, marker = extra.partition(':')
    try:
        _check_marker(marker)
    except packaging.markers.InvalidMarker:
        msg = f"Invalid environment marker: {marker} ({extra!r})"
        raise DistutilsSetupError(msg) from None
    list(_reqs.parse(reqs))


def _check_marker(marker):
    if not marker:
        return
    m = packaging.markers.Marker(marker)
    m.evaluate()


def assert_bool(dist, attr, value):
    """Verify that value is True, False, 0, or 1"""
    if bool(value) != value:
        tmpl = "{attr!r} must be a boolean value (got {value!r})"
        raise DistutilsSetupError(tmpl.format(attr=attr, value=value))


def invalid_unless_false(dist, attr, value):
    if not value:
        DistDeprecationWarning.emit(f"{attr} is ignored.")
        # TODO: should there be a `due_date` here?
        return
    raise DistutilsSetupError(f"{attr} is invalid.")


def check_requirements(dist, attr, value):
    """Verify that install_requires is a valid requirements list"""
    try:
        list(_reqs.parse(value))
        if isinstance(value, (dict, set)):
            raise TypeError("Unordered types are not allowed")
    except (TypeError, ValueError) as error:
        tmpl = (
            "{attr!r} must be a string or list of strings "
            "containing valid project/version requirement specifiers; {error}"
        )
        raise DistutilsSetupError(tmpl.format(attr=attr, error=error)) from error


def check_specifier(dist, attr, value):
    """Verify that value is a valid version specifier"""
    try:
        packaging.specifiers.SpecifierSet(value)
    except (packaging.specifiers.InvalidSpecifier, AttributeError) as error:
        tmpl = (
            "{attr!r} must be a string " "containing valid version specifiers; {error}"
        )
        raise DistutilsSetupError(tmpl.format(attr=attr, error=error)) from error


def check_entry_points(dist, attr, value):
    """Verify that entry_points map is parseable"""
    try:
        _entry_points.load(value)
    except Exception as e:
        raise DistutilsSetupError(e) from e


def check_test_suite(dist, attr, value):
    if not isinstance(value, str):
        raise DistutilsSetupError("test_suite must be a string")


def check_package_data(dist, attr, value):
    """Verify that value is a dictionary of package names to glob lists"""
    if not isinstance(value, dict):
        raise DistutilsSetupError(
            "{!r} must be a dictionary mapping package names to lists of "
            "string wildcard patterns".format(attr)
        )
    for k, v in value.items():
        if not isinstance(k, str):
            raise DistutilsSetupError(
                "keys of {!r} dict must be strings (got {!r})".format(attr, k)
            )
        assert_string_list(dist, 'values of {!r} dict'.format(attr), v)


def check_packages(dist, attr, value):
    for pkgname in value:
        if not re.match(r'\w+(\.\w+)*', pkgname):
            distutils.log.warn(
                "WARNING: %r not a valid package name; please use only "
                ".-separated package names in setup.py",
                pkgname,
            )


_Distribution = get_unpatched(distutils.core.Distribution)


class Distribution(_Distribution):
    """Distribution with support for tests and package data

    This is an enhanced version of 'distutils.dist.Distribution' that
    effectively adds the following new optional keyword arguments to 'setup()':

     'install_requires' -- a string or sequence of strings specifying project
        versions that the distribution requires when installed, in the format
        used by 'pkg_resources.require()'.  They will be installed
        automatically when the package is installed.  If you wish to use
        packages that are not available in PyPI, or want to give your users an
        alternate download location, you can add a 'find_links' option to the
        '[easy_install]' section of your project's 'setup.cfg' file, and then
        setuptools will scan the listed web pages for links that satisfy the
        requirements.

     'extras_require' -- a dictionary mapping names of optional "extras" to the
        additional requirement(s) that using those extras incurs. For example,
        this::

            extras_require = dict(reST = ["docutils>=0.3", "reSTedit"])

        indicates that the distribution can optionally provide an extra
        capability called "reST", but it can only be used if docutils and
        reSTedit are installed.  If the user installs your package using
        EasyInstall and requests one of your extras, the corresponding
        additional requirements will be installed if needed.

     'test_suite' -- the name of a test suite to run for the 'test' command.
        If the user runs 'python setup.py test', the package will be installed,
        and the named test suite will be run.  The format is the same as
        would be used on a 'unittest.py' command line.  That is, it is the
        dotted name of an object to import and call to generate a test suite.

     'package_data' -- a dictionary mapping package names to lists of filenames
        or globs to use to find data files contained in the named packages.
        If the dictionary has filenames or globs listed under '""' (the empty
        string), those names will be searched for in every package, in addition
        to any names for the specific package.  Data files found using these
        names/globs will be installed along with the package, in the same
        location as the package.  Note that globs are allowed to reference
        the contents of non-package subdirectories, as long as you use '/' as
        a path separator.  (Globs are automatically converted to
        platform-specific paths at runtime.)

    In addition to these new keywords, this class also has several new methods
    for manipulating the distribution's contents.  For example, the 'include()'
    and 'exclude()' methods can be thought of as in-place add and subtract
    commands that add or remove packages, modules, extensions, and so on from
    the distribution.
    """

    _DISTUTILS_UNSUPPORTED_METADATA = {
        'long_description_content_type': lambda: None,
        'project_urls': dict,
        'provides_extras': ordered_set.OrderedSet,
        'license_file': lambda: None,
        'license_files': lambda: None,
    }

    _patched_dist = None

    def patch_missing_pkg_info(self, attrs):
        # Fake up a replacement for the data that would normally come from
        # PKG-INFO, but which might not yet be built if this is a fresh
        # checkout.
        #
        if not attrs or 'name' not in attrs or 'version' not in attrs:
            return
        name = _normalization.safe_name(str(attrs['name'])).lower()
        with suppress(metadata.PackageNotFoundError):
            dist = metadata.distribution(name)
            if dist is not None and not dist.read_text('PKG-INFO'):
                dist._version = _normalization.safe_version(str(attrs['version']))
                self._patched_dist = dist

    def __init__(self, attrs=None):
        have_package_data = hasattr(self, "package_data")
        if not have_package_data:
            self.package_data = {}
        attrs = attrs or {}
        self.dist_files = []
        # Filter-out setuptools' specific options.
        self.src_root = attrs.pop("src_root", None)
        self.patch_missing_pkg_info(attrs)
        self.dependency_links = attrs.pop('dependency_links', [])
        self.setup_requires = attrs.pop('setup_requires', [])
        for ep in metadata.entry_points(group='distutils.setup_keywords'):
            vars(self).setdefault(ep.name, None)
        _Distribution.__init__(
            self,
            {
                k: v
                for k, v in attrs.items()
                if k not in self._DISTUTILS_UNSUPPORTED_METADATA
            },
        )

        # Private API (setuptools-use only, not restricted to Distribution)
        # Stores files that are referenced by the configuration and need to be in the
        # sdist (e.g. `version = file: VERSION.txt`)
        self._referenced_files: Set[str] = set()

        # Save the original dependencies before they are processed into the egg format
        self._orig_extras_require = {}
        self._orig_install_requires = []
        self._tmp_extras_require = defaultdict(ordered_set.OrderedSet)

        self.set_defaults = ConfigDiscovery(self)

        self._set_metadata_defaults(attrs)

        self.metadata.version = self._normalize_version(
            self._validate_version(self.metadata.version)
        )
        self._finalize_requires()

    def _validate_metadata(self):
        required = {"name"}
        provided = {
            key
            for key in vars(self.metadata)
            if getattr(self.metadata, key, None) is not None
        }
        missing = required - provided

        if missing:
            msg = f"Required package metadata is missing: {missing}"
            raise DistutilsSetupError(msg)

    def _set_metadata_defaults(self, attrs):
        """
        Fill-in missing metadata fields not supported by distutils.
        Some fields may have been set by other tools (e.g. pbr).
        Those fields (vars(self.metadata)) take precedence to
        supplied attrs.
        """
        for option, default in self._DISTUTILS_UNSUPPORTED_METADATA.items():
            vars(self.metadata).setdefault(option, attrs.get(option, default()))

    @staticmethod
    def _normalize_version(version):
        if isinstance(version, setuptools.sic) or version is None:
            return version

        normalized = str(packaging.version.Version(version))
        if version != normalized:
            InformationOnly.emit(f"Normalizing '{version}' to '{normalized}'")
            return normalized
        return version

    @staticmethod
    def _validate_version(version):
        if isinstance(version, numbers.Number):
            # Some people apparently take "version number" too literally :)
            version = str(version)

        if version is not None:
            try:
                packaging.version.Version(version)
            except (packaging.version.InvalidVersion, TypeError):
                SetuptoolsDeprecationWarning.emit(
                    f"Invalid version: {version!r}.",
                    """
                    The version specified is not a valid version according to PEP 440.
                    This may not work as expected with newer versions of
                    setuptools, pip, and PyPI.
                    """,
                    see_url="https://peps.python.org/pep-0440/",
                    due_date=(2023, 9, 26),
                    # Warning initially introduced in 26 Sept 2014
                    # pypa/packaging already removed legacy versions.
                )
                return setuptools.sic(version)
        return version

    def _finalize_requires(self):
        """
        Set `metadata.python_requires` and fix environment markers
        in `install_requires` and `extras_require`.
        """
        if getattr(self, 'python_requires', None):
            self.metadata.python_requires = self.python_requires

        if getattr(self, 'extras_require', None):
            # Save original before it is messed by _convert_extras_requirements
            self._orig_extras_require = self._orig_extras_require or self.extras_require
            for extra in self.extras_require.keys():
                # Since this gets called multiple times at points where the
                # keys have become 'converted' extras, ensure that we are only
                # truly adding extras we haven't seen before here.
                extra = extra.split(':')[0]
                if extra:
                    self.metadata.provides_extras.add(extra)

        if getattr(self, 'install_requires', None) and not self._orig_install_requires:
            # Save original before it is messed by _move_install_requirements_markers
            self._orig_install_requires = self.install_requires

        self._convert_extras_requirements()
        self._move_install_requirements_markers()

    def _convert_extras_requirements(self):
        """
        Convert requirements in `extras_require` of the form
        `"extra": ["barbazquux; {marker}"]` to
        `"extra:{marker}": ["barbazquux"]`.
        """
        spec_ext_reqs = getattr(self, 'extras_require', None) or {}
        tmp = defaultdict(ordered_set.OrderedSet)
        self._tmp_extras_require = getattr(self, '_tmp_extras_require', tmp)
        for section, v in spec_ext_reqs.items():
            # Do not strip empty sections.
            self._tmp_extras_require[section]
            for r in _reqs.parse(v):
                suffix = self._suffix_for(r)
                self._tmp_extras_require[section + suffix].append(r)

    @staticmethod
    def _suffix_for(req):
        """
        For a requirement, return the 'extras_require' suffix for
        that requirement.
        """
        return ':' + str(req.marker) if req.marker else ''

    def _move_install_requirements_markers(self):
        """
        Move requirements in `install_requires` that are using environment
        markers `extras_require`.
        """

        # divide the install_requires into two sets, simple ones still
        # handled by install_requires and more complex ones handled
        # by extras_require.

        def is_simple_req(req):
            return not req.marker

        spec_inst_reqs = getattr(self, 'install_requires', None) or ()
        inst_reqs = list(_reqs.parse(spec_inst_reqs))
        simple_reqs = filter(is_simple_req, inst_reqs)
        complex_reqs = itertools.filterfalse(is_simple_req, inst_reqs)
        self.install_requires = list(map(str, simple_reqs))

        for r in complex_reqs:
            self._tmp_extras_require[':' + str(r.marker)].append(r)
        self.extras_require = dict(
            # list(dict.fromkeys(...))  ensures a list of unique strings
            (k, list(dict.fromkeys(str(r) for r in map(self._clean_req, v))))
            for k, v in self._tmp_extras_require.items()
        )

    def _clean_req(self, req):
        """
        Given a Requirement, remove environment markers and return it.
        """
        req.marker = None
        return req

    def _finalize_license_files(self):
        """Compute names of all license files which should be included."""
        license_files: Optional[List[str]] = self.metadata.license_files
        patterns: List[str] = license_files if license_files else []

        license_file: Optional[str] = self.metadata.license_file
        if license_file and license_file not in patterns:
            patterns.append(license_file)

        if license_files is None and license_file is None:
            # Default patterns match the ones wheel uses
            # See https://wheel.readthedocs.io/en/stable/user_guide.html
            # -> 'Including license files in the generated wheel file'
            patterns = ('LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*')

        self.metadata.license_files = list(
            unique_everseen(self._expand_patterns(patterns))
        )

    @staticmethod
    def _expand_patterns(patterns):
        """
        >>> list(Distribution._expand_patterns(['LICENSE']))
        ['LICENSE']
        >>> list(Distribution._expand_patterns(['setup.cfg', 'LIC*']))
        ['setup.cfg', 'LICENSE']
        """
        return (
            path
            for pattern in patterns
            for path in sorted(iglob(pattern))
            if not path.endswith('~') and os.path.isfile(path)
        )

    # FIXME: 'Distribution._parse_config_files' is too complex (14)
    def _parse_config_files(self, filenames=None):  # noqa: C901
        """
        Adapted from distutils.dist.Distribution.parse_config_files,
        this method provides the same functionality in subtly-improved
        ways.
        """
        from configparser import ConfigParser

        # Ignore install directory options if we have a venv
        ignore_options = (
            []
            if sys.prefix == sys.base_prefix
            else [
                'install-base',
                'install-platbase',
                'install-lib',
                'install-platlib',
                'install-purelib',
                'install-headers',
                'install-scripts',
                'install-data',
                'prefix',
                'exec-prefix',
                'home',
                'user',
                'root',
            ]
        )

        ignore_options = frozenset(ignore_options)

        if filenames is None:
            filenames = self.find_config_files()

        if DEBUG:
            self.announce("Distribution.parse_config_files():")

        parser = ConfigParser()
        parser.optionxform = str
        for filename in filenames:
            with io.open(filename, encoding='utf-8') as reader:
                if DEBUG:
                    self.announce("  reading {filename}".format(**locals()))
                parser.read_file(reader)
            for section in parser.sections():
                options = parser.options(section)
                opt_dict = self.get_option_dict(section)

                for opt in options:
                    if opt == '__name__' or opt in ignore_options:
                        continue

                    val = parser.get(section, opt)
                    opt = self.warn_dash_deprecation(opt, section)
                    opt = self.make_option_lowercase(opt, section)
                    opt_dict[opt] = (filename, val)

            # Make the ConfigParser forget everything (so we retain
            # the original filenames that options come from)
            parser.__init__()

        if 'global' not in self.command_options:
            return

        # If there was a "global" section in the config file, use it
        # to set Distribution options.

        for opt, (src, val) in self.command_options['global'].items():
            alias = self.negative_opt.get(opt)
            if alias:
                val = not strtobool(val)
            elif opt in ('verbose', 'dry_run'):  # ugh!
                val = strtobool(val)

            try:
                setattr(self, alias or opt, val)
            except ValueError as e:
                raise DistutilsOptionError(e) from e

    def warn_dash_deprecation(self, opt, section):
        if section in (
            'options.extras_require',
            'options.data_files',
        ):
            return opt

        underscore_opt = opt.replace('-', '_')
        commands = list(
            itertools.chain(
                distutils.command.__all__,
                self._setuptools_commands(),
            )
        )
        if (
            not section.startswith('options')
            and section != 'metadata'
            and section not in commands
        ):
            return underscore_opt

        if '-' in opt:
            SetuptoolsDeprecationWarning.emit(
                "Invalid dash-separated options",
                f"""
                Usage of dash-separated {opt!r} will not be supported in future
                versions. Please use the underscore name {underscore_opt!r} instead.
                """,
                see_docs="userguide/declarative_config.html",
                due_date=(2023, 9, 26),
                # Warning initially introduced in 3 Mar 2021
            )
        return underscore_opt

    def _setuptools_commands(self):
        try:
            return metadata.distribution('setuptools').entry_points.names
        except metadata.PackageNotFoundError:
            # during bootstrapping, distribution doesn't exist
            return []

    def make_option_lowercase(self, opt, section):
        if section != 'metadata' or opt.islower():
            return opt

        lowercase_opt = opt.lower()
        SetuptoolsDeprecationWarning.emit(
            "Invalid uppercase configuration",
            f"""
            Usage of uppercase key {opt!r} in {section!r} will not be supported in
            future versions. Please use lowercase {lowercase_opt!r} instead.
            """,
            see_docs="userguide/declarative_config.html",
            due_date=(2023, 9, 26),
            # Warning initially introduced in 6 Mar 2021
        )
        return lowercase_opt

    # FIXME: 'Distribution._set_command_options' is too complex (14)
    def _set_command_options(self, command_obj, option_dict=None):  # noqa: C901
        """
        Set the options for 'command_obj' from 'option_dict'.  Basically
        this means copying elements of a dictionary ('option_dict') to
        attributes of an instance ('command').

        'command_obj' must be a Command instance.  If 'option_dict' is not
        supplied, uses the standard option dictionary for this command
        (from 'self.command_options').

        (Adopted from distutils.dist.Distribution._set_command_options)
        """
        command_name = command_obj.get_command_name()
        if option_dict is None:
            option_dict = self.get_option_dict(command_name)

        if DEBUG:
            self.announce("  setting options for '%s' command:" % command_name)
        for option, (source, value) in option_dict.items():
            if DEBUG:
                self.announce("    %s = %s (from %s)" % (option, value, source))
            try:
                bool_opts = [translate_longopt(o) for o in command_obj.boolean_options]
            except AttributeError:
                bool_opts = []
            try:
                neg_opt = command_obj.negative_opt
            except AttributeError:
                neg_opt = {}

            try:
                is_string = isinstance(value, str)
                if option in neg_opt and is_string:
                    setattr(command_obj, neg_opt[option], not strtobool(value))
                elif option in bool_opts and is_string:
                    setattr(command_obj, option, strtobool(value))
                elif hasattr(command_obj, option):
                    setattr(command_obj, option, value)
                else:
                    raise DistutilsOptionError(
                        "error in %s: command '%s' has no such option '%s'"
                        % (source, command_name, option)
                    )
            except ValueError as e:
                raise DistutilsOptionError(e) from e

    def _get_project_config_files(self, filenames):
        """Add default file and split between INI and TOML"""
        tomlfiles = []
        standard_project_metadata = Path(self.src_root or os.curdir, "pyproject.toml")
        if filenames is not None:
            parts = partition(lambda f: Path(f).suffix == ".toml", filenames)
            filenames = list(parts[0])  # 1st element => predicate is False
            tomlfiles = list(parts[1])  # 2nd element => predicate is True
        elif standard_project_metadata.exists():
            tomlfiles = [standard_project_metadata]
        return filenames, tomlfiles

    def parse_config_files(self, filenames=None, ignore_option_errors=False):
        """Parses configuration files from various levels
        and loads configuration.
        """
        inifiles, tomlfiles = self._get_project_config_files(filenames)

        self._parse_config_files(filenames=inifiles)

        setupcfg.parse_configuration(
            self, self.command_options, ignore_option_errors=ignore_option_errors
        )
        for filename in tomlfiles:
            pyprojecttoml.apply_configuration(self, filename, ignore_option_errors)

        self._finalize_requires()
        self._finalize_license_files()

    def fetch_build_eggs(self, requires):
        """Resolve pre-setup requirements"""
        from setuptools.installer import _fetch_build_eggs

        return _fetch_build_eggs(self, requires)

    def finalize_options(self):
        """
        Allow plugins to apply arbitrary operations to the
        distribution. Each hook may optionally define a 'order'
        to influence the order of execution. Smaller numbers
        go first and the default is 0.
        """
        group = 'setuptools.finalize_distribution_options'

        def by_order(hook):
            return getattr(hook, 'order', 0)

        defined = metadata.entry_points(group=group)
        filtered = itertools.filterfalse(self._removed, defined)
        loaded = map(lambda e: e.load(), filtered)
        for ep in sorted(loaded, key=by_order):
            ep(self)

    @staticmethod
    def _removed(ep):
        """
        When removing an entry point, if metadata is loaded
        from an older version of Setuptools, that removed
        entry point will attempt to be loaded and will fail.
        See #2765 for more details.
        """
        removed = {
            # removed 2021-09-05
            '2to3_doctests',
        }
        return ep.name in removed

    def _finalize_setup_keywords(self):
        for ep in metadata.entry_points(group='distutils.setup_keywords'):
            value = getattr(self, ep.name, None)
            if value is not None:
                ep.load()(self, ep.name, value)

    def get_egg_cache_dir(self):
        egg_cache_dir = os.path.join(os.curdir, '.eggs')
        if not os.path.exists(egg_cache_dir):
            os.mkdir(egg_cache_dir)
            windows_support.hide_file(egg_cache_dir)
            readme_txt_filename = os.path.join(egg_cache_dir, 'README.txt')
            with open(readme_txt_filename, 'w') as f:
                f.write(
                    'This directory contains eggs that were downloaded '
                    'by setuptools to build, test, and run plug-ins.\n\n'
                )
                f.write(
                    'This directory caches those eggs to prevent '
                    'repeated downloads.\n\n'
                )
                f.write('However, it is safe to delete this directory.\n\n')

        return egg_cache_dir

    def fetch_build_egg(self, req):
        """Fetch an egg needed for building"""
        from setuptools.installer import fetch_build_egg

        return fetch_build_egg(self, req)

    def get_command_class(self, command):
        """Pluggable version of get_command_class()"""
        if command in self.cmdclass:
            return self.cmdclass[command]

        eps = metadata.entry_points(group='distutils.commands', name=command)
        for ep in eps:
            self.cmdclass[command] = cmdclass = ep.load()
            return cmdclass
        else:
            return _Distribution.get_command_class(self, command)

    def print_commands(self):
        for ep in metadata.entry_points(group='distutils.commands'):
            if ep.name not in self.cmdclass:
                cmdclass = ep.load()
                self.cmdclass[ep.name] = cmdclass
        return _Distribution.print_commands(self)

    def get_command_list(self):
        for ep in metadata.entry_points(group='distutils.commands'):
            if ep.name not in self.cmdclass:
                cmdclass = ep.load()
                self.cmdclass[ep.name] = cmdclass
        return _Distribution.get_command_list(self)

    def include(self, **attrs):
        """Add items to distribution that are named in keyword arguments

        For example, 'dist.include(py_modules=["x"])' would add 'x' to
        the distribution's 'py_modules' attribute, if it was not already
        there.

        Currently, this method only supports inclusion for attributes that are
        lists or tuples.  If you need to add support for adding to other
        attributes in this or a subclass, you can add an '_include_X' method,
        where 'X' is the name of the attribute.  The method will be called with
        the value passed to 'include()'.  So, 'dist.include(foo={"bar":"baz"})'
        will try to call 'dist._include_foo({"bar":"baz"})', which can then
        handle whatever special inclusion logic is needed.
        """
        for k, v in attrs.items():
            include = getattr(self, '_include_' + k, None)
            if include:
                include(v)
            else:
                self._include_misc(k, v)

    def exclude_package(self, package):
        """Remove packages, modules, and extensions in named package"""

        pfx = package + '.'
        if self.packages:
            self.packages = [
                p for p in self.packages if p != package and not p.startswith(pfx)
            ]

        if self.py_modules:
            self.py_modules = [
                p for p in self.py_modules if p != package and not p.startswith(pfx)
            ]

        if self.ext_modules:
            self.ext_modules = [
                p
                for p in self.ext_modules
                if p.name != package and not p.name.startswith(pfx)
            ]

    def has_contents_for(self, package):
        """Return true if 'exclude_package(package)' would do something"""

        pfx = package + '.'

        for p in self.iter_distribution_names():
            if p == package or p.startswith(pfx):
                return True

    def _exclude_misc(self, name, value):
        """Handle 'exclude()' for list/tuple attrs without a special handler"""
        if not isinstance(value, sequence):
            raise DistutilsSetupError(
                "%s: setting must be a list or tuple (%r)" % (name, value)
            )
        try:
            old = getattr(self, name)
        except AttributeError as e:
            raise DistutilsSetupError("%s: No such distribution setting" % name) from e
        if old is not None and not isinstance(old, sequence):
            raise DistutilsSetupError(
                name + ": this setting cannot be changed via include/exclude"
            )
        elif old:
            setattr(self, name, [item for item in old if item not in value])

    def _include_misc(self, name, value):
        """Handle 'include()' for list/tuple attrs without a special handler"""

        if not isinstance(value, sequence):
            raise DistutilsSetupError("%s: setting must be a list (%r)" % (name, value))
        try:
            old = getattr(self, name)
        except AttributeError as e:
            raise DistutilsSetupError("%s: No such distribution setting" % name) from e
        if old is None:
            setattr(self, name, value)
        elif not isinstance(old, sequence):
            raise DistutilsSetupError(
                name + ": this setting cannot be changed via include/exclude"
            )
        else:
            new = [item for item in value if item not in old]
            setattr(self, name, old + new)

    def exclude(self, **attrs):
        """Remove items from distribution that are named in keyword arguments

        For example, 'dist.exclude(py_modules=["x"])' would remove 'x' from
        the distribution's 'py_modules' attribute.  Excluding packages uses
        the 'exclude_package()' method, so all of the package's contained
        packages, modules, and extensions are also excluded.

        Currently, this method only supports exclusion from attributes that are
        lists or tuples.  If you need to add support for excluding from other
        attributes in this or a subclass, you can add an '_exclude_X' method,
        where 'X' is the name of the attribute.  The method will be called with
        the value passed to 'exclude()'.  So, 'dist.exclude(foo={"bar":"baz"})'
        will try to call 'dist._exclude_foo({"bar":"baz"})', which can then
        handle whatever special exclusion logic is needed.
        """
        for k, v in attrs.items():
            exclude = getattr(self, '_exclude_' + k, None)
            if exclude:
                exclude(v)
            else:
                self._exclude_misc(k, v)

    def _exclude_packages(self, packages):
        if not isinstance(packages, sequence):
            raise DistutilsSetupError(
                "packages: setting must be a list or tuple (%r)" % (packages,)
            )
        list(map(self.exclude_package, packages))

    def _parse_command_opts(self, parser, args):
        # Remove --with-X/--without-X options when processing command args
        self.global_options = self.__class__.global_options
        self.negative_opt = self.__class__.negative_opt

        # First, expand any aliases
        command = args[0]
        aliases = self.get_option_dict('aliases')
        while command in aliases:
            src, alias = aliases[command]
            del aliases[command]  # ensure each alias can expand only once!
            import shlex

            args[:1] = shlex.split(alias, True)
            command = args[0]

        nargs = _Distribution._parse_command_opts(self, parser, args)

        # Handle commands that want to consume all remaining arguments
        cmd_class = self.get_command_class(command)
        if getattr(cmd_class, 'command_consumes_arguments', None):
            self.get_option_dict(command)['args'] = ("command line", nargs)
            if nargs is not None:
                return []

        return nargs

    def get_cmdline_options(self):
        """Return a '{cmd: {opt:val}}' map of all command-line options

        Option names are all long, but do not include the leading '--', and
        contain dashes rather than underscores.  If the option doesn't take
        an argument (e.g. '--quiet'), the 'val' is 'None'.

        Note that options provided by config files are intentionally excluded.
        """

        d = {}

        for cmd, opts in self.command_options.items():
            for opt, (src, val) in opts.items():
                if src != "command line":
                    continue

                opt = opt.replace('_', '-')

                if val == 0:
                    cmdobj = self.get_command_obj(cmd)
                    neg_opt = self.negative_opt.copy()
                    neg_opt.update(getattr(cmdobj, 'negative_opt', {}))
                    for neg, pos in neg_opt.items():
                        if pos == opt:
                            opt = neg
                            val = None
                            break
                    else:
                        raise AssertionError("Shouldn't be able to get here")

                elif val == 1:
                    val = None

                d.setdefault(cmd, {})[opt] = val

        return d

    def iter_distribution_names(self):
        """Yield all packages, modules, and extension names in distribution"""

        for pkg in self.packages or ():
            yield pkg

        for module in self.py_modules or ():
            yield module

        for ext in self.ext_modules or ():
            if isinstance(ext, tuple):
                name, buildinfo = ext
            else:
                name = ext.name
            if name.endswith('module'):
                name = name[:-6]
            yield name

    def handle_display_options(self, option_order):
        """If there were any non-global "display-only" options
        (--help-commands or the metadata display options) on the command
        line, display the requested info and return true; else return
        false.
        """
        import sys

        if self.help_commands:
            return _Distribution.handle_display_options(self, option_order)

        # Stdout may be StringIO (e.g. in tests)
        if not isinstance(sys.stdout, io.TextIOWrapper):
            return _Distribution.handle_display_options(self, option_order)

        # Don't wrap stdout if utf-8 is already the encoding. Provides
        #  workaround for #334.
        if sys.stdout.encoding.lower() in ('utf-8', 'utf8'):
            return _Distribution.handle_display_options(self, option_order)

        # Print metadata in UTF-8 no matter the platform
        encoding = sys.stdout.encoding
        sys.stdout.reconfigure(encoding='utf-8')
        try:
            return _Distribution.handle_display_options(self, option_order)
        finally:
            sys.stdout.reconfigure(encoding=encoding)

    def run_command(self, command):
        self.set_defaults()
        # Postpone defaults until all explicit configuration is considered
        # (setup() args, config files, command line and plugins)

        super().run_command(command)


class DistDeprecationWarning(SetuptoolsDeprecationWarning):
    """Class for warning about deprecations in dist in
    setuptools. Not ignored by default, unlike DeprecationWarning."""
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/errors.py0000644000175100001730000000464014467657412017565 0ustar00runnerdocker"""setuptools.errors

Provides exceptions used by setuptools modules.
"""

from distutils import errors as _distutils_errors


# Re-export errors from distutils to facilitate the migration to PEP632

ByteCompileError = _distutils_errors.DistutilsByteCompileError
CCompilerError = _distutils_errors.CCompilerError
ClassError = _distutils_errors.DistutilsClassError
CompileError = _distutils_errors.CompileError
ExecError = _distutils_errors.DistutilsExecError
FileError = _distutils_errors.DistutilsFileError
InternalError = _distutils_errors.DistutilsInternalError
LibError = _distutils_errors.LibError
LinkError = _distutils_errors.LinkError
ModuleError = _distutils_errors.DistutilsModuleError
OptionError = _distutils_errors.DistutilsOptionError
PlatformError = _distutils_errors.DistutilsPlatformError
PreprocessError = _distutils_errors.PreprocessError
SetupError = _distutils_errors.DistutilsSetupError
TemplateError = _distutils_errors.DistutilsTemplateError
UnknownFileError = _distutils_errors.UnknownFileError

# The root error class in the hierarchy
BaseError = _distutils_errors.DistutilsError


class RemovedCommandError(BaseError, RuntimeError):
    """Error used for commands that have been removed in setuptools.

    Since ``setuptools`` is built on ``distutils``, simply removing a command
    from ``setuptools`` will make the behavior fall back to ``distutils``; this
    error is raised if a command exists in ``distutils`` but has been actively
    removed in ``setuptools``.
    """


class PackageDiscoveryError(BaseError, RuntimeError):
    """Impossible to perform automatic discovery of packages and/or modules.

    The current project layout or given discovery options can lead to problems when
    scanning the project directory.

    Setuptools might also refuse to complete auto-discovery if an error prone condition
    is detected (e.g. when a project is organised as a flat-layout but contains
    multiple directories that can be taken as top-level packages inside a single
    distribution [*]_). In these situations the users are encouraged to be explicit
    about which packages to include or to make the discovery parameters more specific.

    .. [*] Since multi-package distributions are uncommon it is very likely that the
       developers did not intend for all the directories to be packaged, and are just
       leaving auxiliary code in the repository top-level, such as maintenance-related
       scripts.
    """
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/extension.py0000644000175100001730000001272714467657412020272 0ustar00runnerdockerimport re
import functools
import distutils.core
import distutils.errors
import distutils.extension

from .monkey import get_unpatched


def _have_cython():
    """
    Return True if Cython can be imported.
    """
    cython_impl = 'Cython.Distutils.build_ext'
    try:
        # from (cython_impl) import build_ext
        __import__(cython_impl, fromlist=['build_ext']).build_ext
        return True
    except Exception:
        pass
    return False


# for compatibility
have_pyrex = _have_cython

_Extension = get_unpatched(distutils.core.Extension)


class Extension(_Extension):
    """
    Describes a single extension module.

    This means that all source files will be compiled into a single binary file
    ``.`` (with ```` derived from ``name`` and
    ```` defined by one of the values in
    ``importlib.machinery.EXTENSION_SUFFIXES``).

    In the case ``.pyx`` files are passed as ``sources and`` ``Cython`` is **not**
    installed in the build environment, ``setuptools`` may also try to look for the
    equivalent ``.cpp`` or ``.c`` files.

    :arg str name:
      the full name of the extension, including any packages -- ie.
      *not* a filename or pathname, but Python dotted name

    :arg list[str] sources:
      list of source filenames, relative to the distribution root
      (where the setup script lives), in Unix form (slash-separated)
      for portability.  Source files may be C, C++, SWIG (.i),
      platform-specific resource files, or whatever else is recognized
      by the "build_ext" command as source for a Python extension.

    :keyword list[str] include_dirs:
      list of directories to search for C/C++ header files (in Unix
      form for portability)

    :keyword list[tuple[str, str|None]] define_macros:
      list of macros to define; each macro is defined using a 2-tuple:
      the first item corresponding to the name of the macro and the second
      item either a string with its value or None to
      define it without a particular value (equivalent of "#define
      FOO" in source or -DFOO on Unix C compiler command line)

    :keyword list[str] undef_macros:
      list of macros to undefine explicitly

    :keyword list[str] library_dirs:
      list of directories to search for C/C++ libraries at link time

    :keyword list[str] libraries:
      list of library names (not filenames or paths) to link against

    :keyword list[str] runtime_library_dirs:
      list of directories to search for C/C++ libraries at run time
      (for shared extensions, this is when the extension is loaded).
      Setting this will cause an exception during build on Windows
      platforms.

    :keyword list[str] extra_objects:
      list of extra files to link with (eg. object files not implied
      by 'sources', static library that must be explicitly specified,
      binary resource files, etc.)

    :keyword list[str] extra_compile_args:
      any extra platform- and compiler-specific information to use
      when compiling the source files in 'sources'.  For platforms and
      compilers where "command line" makes sense, this is typically a
      list of command-line arguments, but for other platforms it could
      be anything.

    :keyword list[str] extra_link_args:
      any extra platform- and compiler-specific information to use
      when linking object files together to create the extension (or
      to create a new static Python interpreter).  Similar
      interpretation as for 'extra_compile_args'.

    :keyword list[str] export_symbols:
      list of symbols to be exported from a shared extension.  Not
      used on all platforms, and not generally necessary for Python
      extensions, which typically export exactly one symbol: "init" +
      extension_name.

    :keyword list[str] swig_opts:
      any extra options to pass to SWIG if a source file has the .i
      extension.

    :keyword list[str] depends:
      list of files that the extension depends on

    :keyword str language:
      extension language (i.e. "c", "c++", "objc"). Will be detected
      from the source extensions if not provided.

    :keyword bool optional:
      specifies that a build failure in the extension should not abort the
      build process, but simply not install the failing extension.

    :keyword bool py_limited_api:
      opt-in flag for the usage of :doc:`Python's limited API `.

    :raises setuptools.errors.PlatformError: if 'runtime_library_dirs' is
      specified on Windows. (since v63)
    """

    def __init__(self, name, sources, *args, **kw):
        # The *args is needed for compatibility as calls may use positional
        # arguments. py_limited_api may be set only via keyword.
        self.py_limited_api = kw.pop("py_limited_api", False)
        super().__init__(name, sources, *args, **kw)

    def _convert_pyx_sources_to_lang(self):
        """
        Replace sources with .pyx extensions to sources with the target
        language extension. This mechanism allows language authors to supply
        pre-converted sources but to prefer the .pyx sources.
        """
        if _have_cython():
            # the build has Cython, so allow it to compile the .pyx files
            return
        lang = self.language or ''
        target_ext = '.cpp' if lang.lower() == 'c++' else '.c'
        sub = functools.partial(re.sub, '.pyx$', target_ext)
        self.sources = list(map(sub, self.sources))


class Library(Extension):
    """Just like a regular Extension, but built as a library instead"""
././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1692360483.543551
setuptools-68.1.2/setuptools/extern/0000755000175100001730000000000014467657444017205 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/extern/__init__.py0000644000175100001730000000475314467657412021322 0ustar00runnerdockerimport importlib.util
import sys


class VendorImporter:
    """
    A PEP 302 meta path importer for finding optionally-vendored
    or otherwise naturally-installed packages from root_name.
    """

    def __init__(self, root_name, vendored_names=(), vendor_pkg=None):
        self.root_name = root_name
        self.vendored_names = set(vendored_names)
        self.vendor_pkg = vendor_pkg or root_name.replace('extern', '_vendor')

    @property
    def search_path(self):
        """
        Search first the vendor package then as a natural package.
        """
        yield self.vendor_pkg + '.'
        yield ''

    def _module_matches_namespace(self, fullname):
        """Figure out if the target module is vendored."""
        root, base, target = fullname.partition(self.root_name + '.')
        return not root and any(map(target.startswith, self.vendored_names))

    def load_module(self, fullname):
        """
        Iterate over the search path to locate and load fullname.
        """
        root, base, target = fullname.partition(self.root_name + '.')
        for prefix in self.search_path:
            try:
                extant = prefix + target
                __import__(extant)
                mod = sys.modules[extant]
                sys.modules[fullname] = mod
                return mod
            except ImportError:
                pass
        else:
            raise ImportError(
                "The '{target}' package is required; "
                "normally this is bundled with this package so if you get "
                "this warning, consult the packager of your "
                "distribution.".format(**locals())
            )

    def create_module(self, spec):
        return self.load_module(spec.name)

    def exec_module(self, module):
        pass

    def find_spec(self, fullname, path=None, target=None):
        """Return a module spec for vendored names."""
        return (
            importlib.util.spec_from_loader(fullname, self)
            if self._module_matches_namespace(fullname)
            else None
        )

    def install(self):
        """
        Install this importer into sys.meta_path if not already present.
        """
        if self not in sys.meta_path:
            sys.meta_path.append(self)


names = (
    'packaging',
    'ordered_set',
    'more_itertools',
    'importlib_metadata',
    'zipp',
    'importlib_resources',
    'jaraco',
    'typing_extensions',
    'tomli',
)
VendorImporter(__name__, names, 'setuptools._vendor').install()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/glob.py0000644000175100001730000001140414467657412017170 0ustar00runnerdocker"""
Filename globbing utility. Mostly a copy of `glob` from Python 3.5.

Changes include:
 * `yield from` and PEP3102 `*` removed.
 * Hidden files are not ignored.
"""

import os
import re
import fnmatch

__all__ = ["glob", "iglob", "escape"]


def glob(pathname, recursive=False):
    """Return a list of paths matching a pathname pattern.

    The pattern may contain simple shell-style wildcards a la
    fnmatch. However, unlike fnmatch, filenames starting with a
    dot are special cases that are not matched by '*' and '?'
    patterns.

    If recursive is true, the pattern '**' will match any files and
    zero or more directories and subdirectories.
    """
    return list(iglob(pathname, recursive=recursive))


def iglob(pathname, recursive=False):
    """Return an iterator which yields the paths matching a pathname pattern.

    The pattern may contain simple shell-style wildcards a la
    fnmatch. However, unlike fnmatch, filenames starting with a
    dot are special cases that are not matched by '*' and '?'
    patterns.

    If recursive is true, the pattern '**' will match any files and
    zero or more directories and subdirectories.
    """
    it = _iglob(pathname, recursive)
    if recursive and _isrecursive(pathname):
        s = next(it)  # skip empty string
        assert not s
    return it


def _iglob(pathname, recursive):
    dirname, basename = os.path.split(pathname)
    glob_in_dir = glob2 if recursive and _isrecursive(basename) else glob1

    if not has_magic(pathname):
        if basename:
            if os.path.lexists(pathname):
                yield pathname
        else:
            # Patterns ending with a slash should match only directories
            if os.path.isdir(dirname):
                yield pathname
        return

    if not dirname:
        yield from glob_in_dir(dirname, basename)
        return
    # `os.path.split()` returns the argument itself as a dirname if it is a
    # drive or UNC path.  Prevent an infinite recursion if a drive or UNC path
    # contains magic characters (i.e. r'\\?\C:').
    if dirname != pathname and has_magic(dirname):
        dirs = _iglob(dirname, recursive)
    else:
        dirs = [dirname]
    if not has_magic(basename):
        glob_in_dir = glob0
    for dirname in dirs:
        for name in glob_in_dir(dirname, basename):
            yield os.path.join(dirname, name)


# These 2 helper functions non-recursively glob inside a literal directory.
# They return a list of basenames. `glob1` accepts a pattern while `glob0`
# takes a literal basename (so it only has to check for its existence).


def glob1(dirname, pattern):
    if not dirname:
        if isinstance(pattern, bytes):
            dirname = os.curdir.encode('ASCII')
        else:
            dirname = os.curdir
    try:
        names = os.listdir(dirname)
    except OSError:
        return []
    return fnmatch.filter(names, pattern)


def glob0(dirname, basename):
    if not basename:
        # `os.path.split()` returns an empty basename for paths ending with a
        # directory separator.  'q*x/' should match only directories.
        if os.path.isdir(dirname):
            return [basename]
    else:
        if os.path.lexists(os.path.join(dirname, basename)):
            return [basename]
    return []


# This helper function recursively yields relative pathnames inside a literal
# directory.


def glob2(dirname, pattern):
    assert _isrecursive(pattern)
    yield pattern[:0]
    for x in _rlistdir(dirname):
        yield x


# Recursively yields relative pathnames inside a literal directory.
def _rlistdir(dirname):
    if not dirname:
        if isinstance(dirname, bytes):
            dirname = os.curdir.encode('ASCII')
        else:
            dirname = os.curdir
    try:
        names = os.listdir(dirname)
    except os.error:
        return
    for x in names:
        yield x
        path = os.path.join(dirname, x) if dirname else x
        for y in _rlistdir(path):
            yield os.path.join(x, y)


magic_check = re.compile('([*?[])')
magic_check_bytes = re.compile(b'([*?[])')


def has_magic(s):
    if isinstance(s, bytes):
        match = magic_check_bytes.search(s)
    else:
        match = magic_check.search(s)
    return match is not None


def _isrecursive(pattern):
    if isinstance(pattern, bytes):
        return pattern == b'**'
    else:
        return pattern == '**'


def escape(pathname):
    """Escape all special characters."""
    # Escaping is done by wrapping any of "*?[" between square brackets.
    # Metacharacters do not work in the drive part and shouldn't be escaped.
    drive, pathname = os.path.splitdrive(pathname)
    if isinstance(pathname, bytes):
        pathname = magic_check_bytes.sub(br'[\1]', pathname)
    else:
        pathname = magic_check.sub(r'[\1]', pathname)
    return drive + pathname
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/gui-32.exe0000644000175100001730000002700014467657412017403 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$z
2dadadacadasee`daseadasea`dase``daseg`dace`daeadad``dadadadf`daRichdaPEL'hd$0@p@6P`22@0.text `.rdata
0@@.data@(@.rsrcP*@@.reloc`,@BC@U}u@@t	jP0@]UEPjuup01@]Ujuu]US]VWKCu+j]Px0@ȃM3"q3ɉM~SU<\uG&<"u ~Wj\VMU3\F3AFM;|…~Wj\VtE_f"^[]U@@3ʼnEEEhPj0@jhjjjhP0@jhQP0@QAu+ʍ;v8.tH;w퍍IfAIu1@1@A1@WAjPu2Ph1@j0@PG_M3]VhPWWH@;st

t
ujh1@P1@t&1@~1@1@fօ΍QDAuS+jQx0@3ۉQ1@tFFP1@uFP1@ttm\uCƀ"u0Ãu
339EȈtSj\W3ۊoGgtSj\W3ۋ@G;NJt@/u\u5h0@PPPPWփ\PPPPP֍QAu+ʊ

Ӏ\uQ3\\tf;r	H8\ujWPPPl0@=x0@jh׋hPV1@(,x0@jhhWV1@=x0@u/3h1@j0@PrF[^_M3Q]Ëj
AP׋V~{9~*4RC;|勵P39~/4C;|勵}t@V0@Vh1@j0@Pl[^_M3I]Ë΍QAu+ʺy;~0󐋅Y@Au+GB;|ߋx0@jWVh1@PNFu+;~O@ff4h1@PdQDAu+FG;|WDžjh@DžDffffffff0@PPjjjjjjj0@u,hP1@j0@P3[^_M3]Ëj@@0@P0@u,hl1@j0@Pv3[^_M3V]ËM3[^_?]UEPjujupQ0@H];
@@uyVjvVPDj0^tslh"@nP>YYuQcth@Y)$PGYt
Tuj-3PYjh5@/jYP2ۈ]eEܡtV9Yt6WjW1@G9>tVYt6$
Y		0	WV0q.tku	jj{YYE5MEQP{	YYËet2}u	EEMd
Y_^[jVj	uh	tUjD0@uH0@h	@0@P<0@]U$j80@tjY) A@
A@A@A@5A@=A@f8A@f
,A@fA@fA@f%A@f-@@0A@E$A@E(A@E4A@p@@(A@,@@ @@	$@@0@@jXkǀ4@@jXk
@@LjX
@@Lh2@UEVH<AQAk(;tM;Jr
BB;r(;u3^]ËVt d@C@P;t3u2^ð^U}uDC@vru2]eu
jZY]U=EC@t]Vutubt&u"hHC@YuhTC@yYt+20
HC@
LC@
PC@
TC@
XC@
\C@EC@^]j/jh6@KeMZf9@u]<@@PEuLf9@u>E@+PQ|YYt'x$|!EE3Ɂ8ËeE2Md
Y_^[Ut}u	3@C@]U=DC@t}uuuYY]U=HC@uuThHC@BYY#E]UuYH]UeEeP(0@E3EE,0@1E00@1EEP40@EM3E3E3Ë
@@VWN@;tu&;uO@u

Gȉ
@@_
@@^33@ø@h`C@$0@ðhhjguj?hC@H$HHH39@@øC@øC@U$Sj80@tM)j$jPF|xffftfpflfhEEDž@jPEjPEE@EE 0@jXۍEEۉED0@EPH0@uujY[ejL0@t3MZf9u)H<ȁ9PEuf9Auytv2h!@D0@UVW}7>csmu%~uF= t=!t="t=@t_3^]0w0\̃%pC@SV5@5@;sW>t
1@׃;r_^[SV5@5@;sW>t
1@׃;r_^[h"@d5D$l$l$+SVW@@1E3PeuEEEEdUVu6uuuVh2@h@@^]U%tC@$
@@j
80@e3SVW3ɍ}S[wO3ɉWE܋}EGenuE5ineIEE5ntelE3@S[]܉EEljsKSuCE%?=t#=`t=pt=Pt=`t=pu=xC@=xC@=xC@MjXM9E|03S[]܉sKMS]t=xC@]@@tC@@@tC@@@tytq3ЉEUEMj^#;uW@@tC@@@ t; tC@@@#;uEM#;u

@@@5tC@_^[339@@%T0@%X0@%`0@%\0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%1@%0@%0@%0@%0@%t0@%0@%0@%0@%0@%0@%0@%0@%0@%0@UQ=tC@|f}t	}uT]E?t?uét*uéué uøËE8"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999@@@@@failed to create process.
failed to get exit code from process.
%s %s-script.pywCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %s @@p@@@@3@1@3@ 1@'hd
l`3`"3,H3"(##$$$$c$k$@"N%x.text$mn0.idata$51.00cfg$1.CRT$XCA(1.CRT$XCAA,1.CRT$XCZ01.CRT$XIA41.CRT$XIAA81.CRT$XIAC<1.CRT$XIZ@1.CRT$XPAD1.CRT$XPZH1.CRT$XTAL1.CRT$XTZP1.rdata3.rdata$sxdata3\.rdata$voltmd`3l.rdata$zzzdbg5.rtc$IAA5.rtc$IZZ5.rtc$TAA5.rtc$TZZ5<.xdata$x6.idata$26.idata$36.idata$48.idata$6@.data@x.bssP`.rsrc$01`P.rsrc$02,@@@N@a@680L7,9T0l7;t0`7;h07;07<084<17V<0x7v<07<08"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999CreateFileAdGetFinalPathNameByHandleAWaitForSingleObjectQGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dllHmemset__current_exception__current_exception_context5_except_handler4_commonVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspaceB_seh_filter_exeD_set_app_type.__setusermatherr_configure_narrow_argv5_initialize_narrow_environment*_get_initial_narrow_environment8_initterm9_initterm_eXexit%_exitT_set_fmode_cexit_c_exit?_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode6_initialize_onexit_table>_register_onexit_function_crt_atexit_controlfp_sjterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllUnhandledExceptionFilterSetUnhandledExceptionFilter,GetCurrentProcessTerminateProcessIsProcessorFeaturePresentmQueryPerformanceCounter-GetCurrentProcessId1GetCurrentThreadIdGetSystemTimeAsFileTimeInitializeSListHeadIsDebuggerPresentGetModuleHandleWDN@0	H`P}

  
    
      
        
      
    
  

00'0[00J1u11112
222:2222222+3>3g3&494s4M5S5w555555666>7I777(8P8Y8a888888!949x99:3:H:M:R:s:x:::;;;;;;;;;;;;<<<<<#<+<3<;>> >*>>>>>?'?0?=?S?????? 000%0011;1z11111122*2A2^222222u3~33333333+444=4K4T4v4}4444444444444444444455555 5&5,52585>5D5J5T50(1(1418122L2P2X2225566././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/gui-64.exe0000644000175100001730000003400014467657412017406 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$bc1c1c161c10c1X1c10c10c10c10c1c1c10c1Z1c10c1Richc1PEd'hd"$"0@`:p`053@0P.text `.rdata,0@@.dataHP0@.pdata`2@@.rsrcp4@@.reloc06@BH)FH(u
"@t3 H(HT$LD$LL$ SVWH0HHt$`HE3Ht$ LHH!H0_^[A5H\$Hl$Ht$H|$ ATAVAWH HLHDH<u, 3LA?L3H3!tKH"!u3H@ta@	!ttO@\u@"u׃u	33EtLDz\IL3@tA6I딅tLDz\IL3AIIcAAMt@t,y tDKHc u;8H\$@IHl$HHt$PH|$XH A_A^A\H\$Hl$Ht$H|$ AVH HHHǀ<9u?HcH3HcL"HX~X<\u&<"u ~\DH	H3\H3HƈHHu~\DHHHl$8IHt$@H|$Hf"H\$0H A^@UVWATH$HHH=H3H DD$dDHT$xAL$`HU33HMHt$0E3D$(D$ DFE3HUHAHMHH@84uHMHHMH;v8.t@0HMHH;wHM@0Hf@8qHIu~3ҋ~AHMXu$H.HLEHXSGH$HL$8AL$0HcHHًHHȐHH;st

t
uA@0HHt)HT$XHLHHtLH/uA\uHHLHD$ LHT$P@8t$P\HLHD$ LHT$PHMHH@8tH@uDHA\uDAHAHEA\t!ffHH;r@0HȀ8\uLHt$ LHT$PH(8HHAHL2Mu(IAOLHFHAGW|$XL$@A6>6HG66H [ù^HLMZf9uxHc
LH	Hʁ9PEu_f9AuTL+QHHAHLH$I;tJL;r
BL;rH(3Hu2z$}2
22H@SH 3҅tuH>5H [@SH =35tu6/H [@SH H=5HuBHH
4+3҅HDHH [H(HH(H\$UHH0H.H2-+H;utHeHMFHEHE@H1E<HMH1E4EHMH H3EH3EH3HH#H3-+H;HDHa.H\$PHHJ.H0]3̸̸@H
94H%̰H14H(H$HH(39.H!4H4Ã%3H\$UH$@HٹVt)3HMAHM1HHHE3
Ht
%@
%
%
%
%%z
%%
%
%
%
%
%
%
%t
%~
%
%"
%
%%@
%B
%
%F
%
%
%
%	ffff%
@UH HHHыH ]@UHH3Ɂ8]0=>=Z=p=====AAB"B@BTBCBBBBBBhBA==>(>"Cb>n> @X>
@?@@@\@?@???|>?n?>>??L?2?x@?@?>>>@0@@>>>!@!@P'@p'@p'@4'@@@@failed to create process.
failed to get exit code from process.
%s %s-script.pywCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %sPP@P@@P@P2@`2@5@X2@h2@p2@x2@2@'hd
5!5,54 "#%%>&
v'6@.text$mn@'6.text$mn$00v'6.text$x0P.idata$5P28.00cfg2.CRT$XCA2.CRT$XCAA2.CRT$XCZ2.CRT$XIA2.CRT$XIAA2.CRT$XIAC2.CRT$XIZ2.CRT$XPA2.CRT$XPZ2.CRT$XTA2.CRT$XTZ2.rdata5\.rdata$voltmd5.rdata$zzzdbg`8.rtc$IAAh8.rtc$IZZp8.rtc$TAAx8.rtc$TZZ8.xdata:.idata$2:.idata$3:P.idata$40=.idata$6P@.data@P.bss`.pdatap`.rsrc$01`p.rsrc$02Rp`0
t	dT42td
T	42B&p`P  !''48!<8!<8!8020	d	4Rp&v'(v'2P		brp`0	"&e 'e P

4

RP4P

4
2pd4p:=0;F>0;@1;@00<@P1<A1=>A02<`A01<A 1 <A@10=>=Z=p=====AAB"B@BTBCBBBBBBhBA==>(>"Cb>n> @X>
@?@@@\@?@???|>?n?>>??L?2?x@?@?>>>@0@@>>>CreateFileAkGetFinalPathNameByHandleAWaitForSingleObjectXGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dll>memset__C_specific_handler__current_exception__current_exception_contextVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspace@_seh_filter_exeB_set_app_type	__setusermatherr_configure_narrow_argv3_initialize_narrow_environment(_get_initial_narrow_environment6_initterm7_initterm_eUexit#_exitT_set_fmode_cexit_c_exit=_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode4_initialize_onexit_table<_register_onexit_function_crt_atexitgterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllRtlCaptureContextRtlLookupFunctionEntryRtlVirtualUnwindUnhandledExceptionFilterSetUnhandledExceptionFilter2GetCurrentProcessTerminateProcessIsProcessorFeaturePresentpQueryPerformanceCounter3GetCurrentProcessId7GetCurrentThreadId
GetSystemTimeAsFileTimeInitializeSListHeadIsDebuggerPresentGetModuleHandleW<memcpy] f2-+48@8888<8<89 98 =8@0989<9880D90B8Dx<9xJ9L98E<9H<9l 9l  <9  <9  <9 !8!!9!"80"{#9##8#C$9D$$9$$9$h&9P'R'9p'v':v''|9''90	H`p}

  
    
      
        
      
    
  

00PX`hp(@HФ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/gui-arm64.exe0000644000175100001730000003300014467657412020105 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$b1111101x11010101011101z1101Rich1PEd'hd"$@`8p` $4p3@0.text4 `.rdata0@@.dataP.@.pdata `0@@.rsrcp2@@.reloc$4@BC11@c1_1@1@c0TC_ {C{A_0"@AT_{0"11@1@G!> (_{5(!@4@R? R{_S{@@?{@SŨ_S[c{i9*i4	85	qT"Q@i9i4I85IK) !Q5i@!|@Q?a&i9"4	85"˟q-T†@3rɂ_*9	j4
85	KQU5{cB[ASè_"RS[ck#{i9i4	85i@?@`9RR?4`8(@?֠5t84h@*?@44rqaTqTraT_qq~4*RrB6R484*RhB6R8(({(4`9(@?4`8@?֠5h9H5{#@kCcB[ASŨ_S[c{i9i4	85˨z
i@!?XRR9qTRh9qqaTqaTqT*R$B6R8Rh8Q8u5qT*RB6y{@cB[ASĨ_{S[ck+@** R?@RdR"RR?@R R?9i4	85		(	)T
9_qT9	HT99j4*85R*9)
8*i(85R*1aT@@R?@R 
*
 *
T	9?q$Jz$Mz!T9AB
? 4	!(@W(	@(19
9S
@9)4R?qATj9	9I5Y@C?C9h59qqTY@C?9i4	85		*H	9?qqTI8H	?qqT	T9
8_qqaT]@C?i@!Ҁ ?i@!Ҁ ?@ ?֗@@R@?a!@R|@ҺH@i@?6# q-T#xQ`@Q5"q
Ts"Q`@Q54@?@@R?
@RG*O!R=OAAAa
RCa@?@R$R?@5@@R?A
R3@(	!	@@?
@@S?@5@@R?
R@f+@kDcC[BSA{ƨ_S{~@@@?qZ{@SŨ_#{h@	~(ia(!L R{#_#{ R* RS42!k54	}SH4{5{A#_R>#{R{#_#{{#_#S{ RSH4RC9iS3h*@q
Th5(Rh*	!	N`4RB	CHRh*5RC9*h@SH4h@AR1
A ??th@Sh4`@8@@E*iS(4U5#R R*	*^S4C@9H5*{¨@S¨#_RMRK**>#{{#_#{4	@(
?`TH_hIȱ5;(R{#_ R#{)(@9q(9Sh5RS5R R{#_#S{3hA9*h5qT4t5(5(A4R
(		%		(A	%		(Rh9 R{S#_֠R>#{IRh@y	kTh=@j(	RH@	k!TH1@y-qTH)@y
aI
@y
+!
@T

@A*T		@)
A)ThR
%@h6R RRR{¨#_#{S145ȿ;{A#_#{@9S)SH45*c*a R{A#_#{	(@aTY Rq`{A#_#{Z{#_#S{h@XT)@c?@%@?@	|@(!@?@	|@(-@?@#@		@)C(	@?Xh(	{èS#_ 2-+3-+R_ R_R_1@__#{	@(@{#_@q_A_!_`>_#{9@?֠@yIR	k!T<@	R
(H@	kaTH1@y-qTH@9qTH@qR{#_!5@#S{@h@	kTh@q!Ti"@(K	q)TH?kTR{S#_Q@Q> csm @#S{	(!3!BTh@1
A ??T{S#_#S{	(!3!BTh@1
A ??T{S#_C@R`>C_@q_F@B@J@N@@@@@z@@@@@@@@@@@@r@f@@@@@@@@@R@#{(@@ {#_a#{@	@?k{#_a;;;;<<.<F<^@t@@D@@@@z<p<<<@<<><>=?>H>R>\>==>>>2>?<
=*>==|=>D=?,?$?*==>:>r=h=^="@@&@8@X@@failed to create process.
failed to get exit code from process.
%s %s-script.pywCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %sP@0Q@@P@2@2@ 2@(2@'hd
h5!.text.text$mn&d.text$x0.idata$52 .00cfg02.CRT$XCA82.CRT$XCAA@2.CRT$XCZH2.CRT$XIAP2.CRT$XIAAX2.CRT$XIAC`2.CRT$XIZh2.CRT$XPAp2.CRT$XPZx2.CRT$XTA2.CRT$XTZ2p.rdata5h.rdata$zzzdbgh7.rtc$IAAp7.rtc$IZZx7.rtc$TAA7.rtc$TZZ78.xdata8.idata$29.idata$39.idata$4;F.idata$6P .data P.bss` .pdatap`.rsrc$01`p.rsrc$02`"Ђ*Ђ*`"Ђ*Ђ*^0 
ɈȄ@@@@BB/@(@kP]@Ђ$h%&&@@@5ph%\ '\ 
@@@*@#@"%@@"9b<0 :<0h:6?0P:V?0:|?1H;?1;?1:?0:@0:"@1;;;;<<.<F<^@t@@D@@@@z<p<<<@<<><>=?>H>R>\>==>>>2>?<
=*>==|=>D=?,?$?*==>:>r=h=^=CreateFileAiGetFinalPathNameByHandleAWaitForSingleObjectVGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dll=memset__C_specific_handler__current_exception__current_exception_contextVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspace@_seh_filter_exeB_set_app_type	__setusermatherr_configure_narrow_argv3_initialize_narrow_environment(_get_initial_narrow_environment6_initterm7_initterm_eUexit#_exitT_set_fmode_cexit_c_exit=_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode4_initialize_onexit_table<_register_onexit_function_crt_atexitgterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllkQueryPerformanceCounter2GetCurrentProcessId6GetCurrentThreadIdGetSystemTimeAsFileTimeInitializeSListHeadSetUnhandledExceptionFilterGetModuleHandleW;memcpy] f2-+7 7P7pL8X8857p%fi0077=X7!8%`8!08a8`8p AA MA!QAP!%x!B"=0##8`$eB$eB0%&@8'80	H`p}

  
    
      
        
      
    
  

0$(8PXX`ȣ裠././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/gui.exe0000644000175100001730000002700014467657412017161 0ustar00runnerdockerMZ@	!L!This program cannot be run in DOS mode.

$z
2dadadacadasee`daseadasea`dase``daseg`dace`daeadad``dadadadf`daRichdaPEL'hd$0@p@6P`22@0.text `.rdata
0@@.data@(@.rsrcP*@@.reloc`,@BC@U}u@@t	jP0@]UEPjuup01@]Ujuu]US]VWKCu+j]Px0@ȃM3"q3ɉM~SU<\uG&<"u ~Wj\VMU3\F3AFM;|…~Wj\VtE_f"^[]U@@3ʼnEEEhPj0@jhjjjhP0@jhQP0@QAu+ʍ;v8.tH;w퍍IfAIu1@1@A1@WAjPu2Ph1@j0@PG_M3]VhPWWH@;st

t
ujh1@P1@t&1@~1@1@fօ΍QDAuS+jQx0@3ۉQ1@tFFP1@uFP1@ttm\uCƀ"u0Ãu
339EȈtSj\W3ۊoGgtSj\W3ۋ@G;NJt@/u\u5h0@PPPPWփ\PPPPP֍QAu+ʊ

Ӏ\uQ3\\tf;r	H8\ujWPPPl0@=x0@jh׋hPV1@(,x0@jhhWV1@=x0@u/3h1@j0@PrF[^_M3Q]Ëj
AP׋V~{9~*4RC;|勵P39~/4C;|勵}t@V0@Vh1@j0@Pl[^_M3I]Ë΍QAu+ʺy;~0󐋅Y@Au+GB;|ߋx0@jWVh1@PNFu+;~O@ff4h1@PdQDAu+FG;|WDžjh@DžDffffffff0@PPjjjjjjj0@u,hP1@j0@P3[^_M3]Ëj@@0@P0@u,hl1@j0@Pv3[^_M3V]ËM3[^_?]UEPjujupQ0@H];
@@uyVjvVPDj0^tslh"@nP>YYuQcth@Y)$PGYt
Tuj-3PYjh5@/jYP2ۈ]eEܡtV9Yt6WjW1@G9>tVYt6$
Y		0	WV0q.tku	jj{YYE5MEQP{	YYËet2}u	EEMd
Y_^[jVj	uh	tUjD0@uH0@h	@0@P<0@]U$j80@tjY) A@
A@A@A@5A@=A@f8A@f
,A@fA@fA@f%A@f-@@0A@E$A@E(A@E4A@p@@(A@,@@ @@	$@@0@@jXkǀ4@@jXk
@@LjX
@@Lh2@UEVH<AQAk(;tM;Jr
BB;r(;u3^]ËVt d@C@P;t3u2^ð^U}uDC@vru2]eu
jZY]U=EC@t]Vutubt&u"hHC@YuhTC@yYt+20
HC@
LC@
PC@
TC@
XC@
\C@EC@^]j/jh6@KeMZf9@u]<@@PEuLf9@u>E@+PQ|YYt'x$|!EE3Ɂ8ËeE2Md
Y_^[Ut}u	3@C@]U=DC@t}uuuYY]U=HC@uuThHC@BYY#E]UuYH]UeEeP(0@E3EE,0@1E00@1EEP40@EM3E3E3Ë
@@VWN@;tu&;uO@u

Gȉ
@@_
@@^33@ø@h`C@$0@ðhhjguj?hC@H$HHH39@@øC@øC@U$Sj80@tM)j$jPF|xffftfpflfhEEDž@jPEjPEE@EE 0@jXۍEEۉED0@EPH0@uujY[ejL0@t3MZf9u)H<ȁ9PEuf9Auytv2h!@D0@UVW}7>csmu%~uF= t=!t="t=@t_3^]0w0\̃%pC@SV5@5@;sW>t
1@׃;r_^[SV5@5@;sW>t
1@׃;r_^[h"@d5D$l$l$+SVW@@1E3PeuEEEEdUVu6uuuVh2@h@@^]U%tC@$
@@j
80@e3SVW3ɍ}S[wO3ɉWE܋}EGenuE5ineIEE5ntelE3@S[]܉EEljsKSuCE%?=t#=`t=pt=Pt=`t=pu=xC@=xC@=xC@MjXM9E|03S[]܉sKMS]t=xC@]@@tC@@@tC@@@tytq3ЉEUEMj^#;uW@@tC@@@ t; tC@@@#;uEM#;u

@@@5tC@_^[339@@%T0@%X0@%`0@%\0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%0@%1@%0@%0@%0@%0@%t0@%0@%0@%0@%0@%0@%0@%0@%0@%0@UQ=tC@|f}t	}uT]E?t?uét*uéué uøËE8"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999@@@@@failed to create process.
failed to get exit code from process.
%s %s-script.pywCannot open %s
#!#!python.exeCannot find Python executable %s
Could not exec %s @@p@@@@3@1@3@ 1@'hd
l`3`"3,H3"(##$$$$c$k$@"N%x.text$mn0.idata$51.00cfg$1.CRT$XCA(1.CRT$XCAA,1.CRT$XCZ01.CRT$XIA41.CRT$XIAA81.CRT$XIAC<1.CRT$XIZ@1.CRT$XPAD1.CRT$XPZH1.CRT$XTAL1.CRT$XTZP1.rdata3.rdata$sxdata3\.rdata$voltmd`3l.rdata$zzzdbg5.rtc$IAA5.rtc$IZZ5.rtc$TAA5.rtc$TZZ5<.xdata$x6.idata$26.idata$36.idata$48.idata$6@.data@x.bssP`.rsrc$01`P.rsrc$02,@@@N@a@680L7,9T0l7;t0`7;h07;07<084<17V<0x7v<07<08"8>8T8j8|888==~=h=R=8===<<<=8898T9H9;>9::;:v:T:&;B;^;:l;|;:2:::99b9p9::9~9;;;;9:999CreateFileAdGetFinalPathNameByHandleAWaitForSingleObjectQGetExitCodeProcessCreateProcessAGetModuleFileNameASetConsoleCtrlHandlerGenerateConsoleCtrlEventKERNEL32.dllHmemset__current_exception__current_exception_context5_except_handler4_commonVCRUNTIME140.dllcalloc_makepath_splitpath__p___argc__p___argv__acrt_iob_func__stdio_common_vfprintf
__stdio_common_vsprintfstrncmpstrncpynisspaceB_seh_filter_exeD_set_app_type.__setusermatherr_configure_narrow_argv5_initialize_narrow_environment*_get_initial_narrow_environment8_initterm9_initterm_eXexit%_exitT_set_fmode_cexit_c_exit?_register_thread_local_exe_atexit_callback_configthreadlocale_set_new_mode__p__commode6_initialize_onexit_table>_register_onexit_function_crt_atexit_controlfp_sjterminate_execvI_openR_read_closeapi-ms-win-crt-heap-l1-1-0.dllapi-ms-win-crt-filesystem-l1-1-0.dllapi-ms-win-crt-runtime-l1-1-0.dllapi-ms-win-crt-stdio-l1-1-0.dllapi-ms-win-crt-string-l1-1-0.dllapi-ms-win-crt-math-l1-1-0.dllapi-ms-win-crt-locale-l1-1-0.dllapi-ms-win-crt-process-l1-1-0.dllUnhandledExceptionFilterSetUnhandledExceptionFilter,GetCurrentProcessTerminateProcessIsProcessorFeaturePresentmQueryPerformanceCounter-GetCurrentProcessId1GetCurrentThreadIdGetSystemTimeAsFileTimeInitializeSListHeadIsDebuggerPresentGetModuleHandleWDN@0	H`P}

  
    
      
        
      
    
  

00'0[00J1u11112
222:2222222+3>3g3&494s4M5S5w555555666>7I777(8P8Y8a888888!949x99:3:H:M:R:s:x:::;;;;;;;;;;;;<<<<<#<+<3<;>> >*>>>>>?'?0?=?S?????? 000%0011;1z11111122*2A2^222222u3~33333333+444=4K4T4v4}4444444444444444444455555 5&5,52585>5D5J5T50(1(1418122L2P2X2225566././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/installer.py0000644000175100001730000001157514467657412020253 0ustar00runnerdockerimport glob
import os
import subprocess
import sys
import tempfile
from distutils import log
from distutils.errors import DistutilsError
from functools import partial

from . import _reqs
from .wheel import Wheel
from .warnings import SetuptoolsDeprecationWarning


def _fixup_find_links(find_links):
    """Ensure find-links option end-up being a list of strings."""
    if isinstance(find_links, str):
        return find_links.split()
    assert isinstance(find_links, (tuple, list))
    return find_links


def fetch_build_egg(dist, req):
    """Fetch an egg needed for building.

    Use pip/wheel to fetch/build a wheel."""
    _DeprecatedInstaller.emit()
    _warn_wheel_not_available(dist)
    return _fetch_build_egg_no_warn(dist, req)


def _fetch_build_eggs(dist, requires):
    import pkg_resources  # Delay import to avoid unnecessary side-effects

    _DeprecatedInstaller.emit(stacklevel=3)
    _warn_wheel_not_available(dist)

    resolved_dists = pkg_resources.working_set.resolve(
        _reqs.parse(requires, pkg_resources.Requirement),  # required for compatibility
        installer=partial(_fetch_build_egg_no_warn, dist),  # avoid warning twice
        replace_conflicting=True,
    )
    for dist in resolved_dists:
        pkg_resources.working_set.add(dist, replace=True)
    return resolved_dists


def _fetch_build_egg_no_warn(dist, req):  # noqa: C901  # is too complex (16)  # FIXME
    import pkg_resources  # Delay import to avoid unnecessary side-effects

    # Ignore environment markers; if supplied, it is required.
    req = strip_marker(req)
    # Take easy_install options into account, but do not override relevant
    # pip environment variables (like PIP_INDEX_URL or PIP_QUIET); they'll
    # take precedence.
    opts = dist.get_option_dict('easy_install')
    if 'allow_hosts' in opts:
        raise DistutilsError(
            'the `allow-hosts` option is not supported '
            'when using pip to install requirements.'
        )
    quiet = 'PIP_QUIET' not in os.environ and 'PIP_VERBOSE' not in os.environ
    if 'PIP_INDEX_URL' in os.environ:
        index_url = None
    elif 'index_url' in opts:
        index_url = opts['index_url'][1]
    else:
        index_url = None
    find_links = (
        _fixup_find_links(opts['find_links'][1])[:] if 'find_links' in opts else []
    )
    if dist.dependency_links:
        find_links.extend(dist.dependency_links)
    eggs_dir = os.path.realpath(dist.get_egg_cache_dir())
    environment = pkg_resources.Environment()
    for egg_dist in pkg_resources.find_distributions(eggs_dir):
        if egg_dist in req and environment.can_add(egg_dist):
            return egg_dist
    with tempfile.TemporaryDirectory() as tmpdir:
        cmd = [
            sys.executable,
            '-m',
            'pip',
            '--disable-pip-version-check',
            'wheel',
            '--no-deps',
            '-w',
            tmpdir,
        ]
        if quiet:
            cmd.append('--quiet')
        if index_url is not None:
            cmd.extend(('--index-url', index_url))
        for link in find_links or []:
            cmd.extend(('--find-links', link))
        # If requirement is a PEP 508 direct URL, directly pass
        # the URL to pip, as `req @ url` does not work on the
        # command line.
        cmd.append(req.url or str(req))
        try:
            subprocess.check_call(cmd)
        except subprocess.CalledProcessError as e:
            raise DistutilsError(str(e)) from e
        wheel = Wheel(glob.glob(os.path.join(tmpdir, '*.whl'))[0])
        dist_location = os.path.join(eggs_dir, wheel.egg_name())
        wheel.install_as_egg(dist_location)
        dist_metadata = pkg_resources.PathMetadata(
            dist_location, os.path.join(dist_location, 'EGG-INFO')
        )
        dist = pkg_resources.Distribution.from_filename(
            dist_location, metadata=dist_metadata
        )
        return dist


def strip_marker(req):
    """
    Return a new requirement without the environment marker to avoid
    calling pip with something like `babel; extra == "i18n"`, which
    would always be ignored.
    """
    import pkg_resources  # Delay import to avoid unnecessary side-effects

    # create a copy to avoid mutating the input
    req = pkg_resources.Requirement.parse(str(req))
    req.marker = None
    return req


def _warn_wheel_not_available(dist):
    import pkg_resources  # Delay import to avoid unnecessary side-effects

    try:
        pkg_resources.get_distribution('wheel')
    except pkg_resources.DistributionNotFound:
        dist.announce('WARNING: The wheel package is not available.', log.WARN)


class _DeprecatedInstaller(SetuptoolsDeprecationWarning):
    _SUMMARY = "setuptools.installer and fetch_build_eggs are deprecated."
    _DETAILS = """
    Requirements should be satisfied by a PEP 517 installer.
    If you are using pip, you can try `pip install --use-pep517`.
    """
    # _DUE_DATE not decided yet
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/launch.py0000644000175100001730000000145414467657412017523 0ustar00runnerdocker"""
Launch the Python script on the command line after
setuptools is bootstrapped via import.
"""

# Note that setuptools gets imported implicitly by the
# invocation of this script using python -m setuptools.launch

import tokenize
import sys


def run():
    """
    Run the script in sys.argv[1] as if it had
    been invoked naturally.
    """
    __builtins__
    script_name = sys.argv[1]
    namespace = dict(
        __file__=script_name,
        __name__='__main__',
        __doc__=None,
    )
    sys.argv[:] = sys.argv[1:]

    open_ = getattr(tokenize, 'open', open)
    with open_(script_name) as fid:
        script = fid.read()
    norm_script = script.replace('\\r\\n', '\\n')
    code = compile(norm_script, script_name, 'exec')
    exec(code, namespace)


if __name__ == '__main__':
    run()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/logging.py0000644000175100001730000000232714467657412017677 0ustar00runnerdockerimport sys
import inspect
import logging
import distutils.log
from . import monkey


def _not_warning(record):
    return record.levelno < logging.WARNING


def configure():
    """
    Configure logging to emit warning and above to stderr
    and everything else to stdout. This behavior is provided
    for compatibility with distutils.log but may change in
    the future.
    """
    err_handler = logging.StreamHandler()
    err_handler.setLevel(logging.WARNING)
    out_handler = logging.StreamHandler(sys.stdout)
    out_handler.addFilter(_not_warning)
    handlers = err_handler, out_handler
    logging.basicConfig(
        format="{message}", style='{', handlers=handlers, level=logging.DEBUG
    )
    if inspect.ismodule(distutils.dist.log):
        monkey.patch_func(set_threshold, distutils.log, 'set_threshold')
        # For some reason `distutils.log` module is getting cached in `distutils.dist`
        # and then loaded again when patched,
        # implying: id(distutils.log) != id(distutils.dist.log).
        # Make sure the same module object is used everywhere:
        distutils.dist.log = distutils.log


def set_threshold(level):
    logging.root.setLevel(level * 10)
    return set_threshold.unpatched(level)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/monkey.py0000644000175100001730000001111614467657412017547 0ustar00runnerdocker"""
Monkey patching of distutils.
"""

import sys
import distutils.filelist
import platform
import types
import functools
from importlib import import_module
import inspect

import setuptools

__all__ = []
"""
Everything is private. Contact the project team
if you think you need this functionality.
"""


def _get_mro(cls):
    """
    Returns the bases classes for cls sorted by the MRO.

    Works around an issue on Jython where inspect.getmro will not return all
    base classes if multiple classes share the same name. Instead, this
    function will return a tuple containing the class itself, and the contents
    of cls.__bases__. See https://github.com/pypa/setuptools/issues/1024.
    """
    if platform.python_implementation() == "Jython":
        return (cls,) + cls.__bases__
    return inspect.getmro(cls)


def get_unpatched(item):
    lookup = (
        get_unpatched_class
        if isinstance(item, type)
        else get_unpatched_function
        if isinstance(item, types.FunctionType)
        else lambda item: None
    )
    return lookup(item)


def get_unpatched_class(cls):
    """Protect against re-patching the distutils if reloaded

    Also ensures that no other distutils extension monkeypatched the distutils
    first.
    """
    external_bases = (
        cls for cls in _get_mro(cls) if not cls.__module__.startswith('setuptools')
    )
    base = next(external_bases)
    if not base.__module__.startswith('distutils'):
        msg = "distutils has already been patched by %r" % cls
        raise AssertionError(msg)
    return base


def patch_all():
    # we can't patch distutils.cmd, alas
    distutils.core.Command = setuptools.Command

    has_issue_12885 = sys.version_info <= (3, 5, 3)

    if has_issue_12885:
        # fix findall bug in distutils (http://bugs.python.org/issue12885)
        distutils.filelist.findall = setuptools.findall

    needs_warehouse = (3, 4) < sys.version_info < (3, 4, 6) or (
        3,
        5,
    ) < sys.version_info <= (3, 5, 3)

    if needs_warehouse:
        warehouse = 'https://upload.pypi.org/legacy/'
        distutils.config.PyPIRCCommand.DEFAULT_REPOSITORY = warehouse

    _patch_distribution_metadata()

    # Install Distribution throughout the distutils
    for module in distutils.dist, distutils.core, distutils.cmd:
        module.Distribution = setuptools.dist.Distribution

    # Install the patched Extension
    distutils.core.Extension = setuptools.extension.Extension
    distutils.extension.Extension = setuptools.extension.Extension
    if 'distutils.command.build_ext' in sys.modules:
        sys.modules[
            'distutils.command.build_ext'
        ].Extension = setuptools.extension.Extension

    patch_for_msvc_specialized_compiler()


def _patch_distribution_metadata():
    """Patch write_pkg_file and read_pkg_file for higher metadata standards"""
    for attr in ('write_pkg_file', 'read_pkg_file', 'get_metadata_version'):
        new_val = getattr(setuptools.dist, attr)
        setattr(distutils.dist.DistributionMetadata, attr, new_val)


def patch_func(replacement, target_mod, func_name):
    """
    Patch func_name in target_mod with replacement

    Important - original must be resolved by name to avoid
    patching an already patched function.
    """
    original = getattr(target_mod, func_name)

    # set the 'unpatched' attribute on the replacement to
    # point to the original.
    vars(replacement).setdefault('unpatched', original)

    # replace the function in the original module
    setattr(target_mod, func_name, replacement)


def get_unpatched_function(candidate):
    return getattr(candidate, 'unpatched')


def patch_for_msvc_specialized_compiler():
    """
    Patch functions in distutils to use standalone Microsoft Visual C++
    compilers.
    """
    # import late to avoid circular imports on Python < 3.5
    msvc = import_module('setuptools.msvc')

    if platform.system() != 'Windows':
        # Compilers only available on Microsoft Windows
        return

    def patch_params(mod_name, func_name):
        """
        Prepare the parameters for patch_func to patch indicated function.
        """
        repl_prefix = 'msvc14_'
        repl_name = repl_prefix + func_name.lstrip('_')
        repl = getattr(msvc, repl_name)
        mod = import_module(mod_name)
        if not hasattr(mod, func_name):
            raise ImportError(func_name)
        return repl, mod, func_name

    # Python 3.5+
    msvc14 = functools.partial(patch_params, 'distutils._msvccompiler')

    try:
        # Patch distutils._msvccompiler._get_vc_env
        patch_func(*msvc14('_get_vc_env'))
    except ImportError:
        pass
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/msvc.py0000644000175100001730000013460714467657412017230 0ustar00runnerdocker"""
Improved support for Microsoft Visual C++ compilers.

Known supported compilers:
--------------------------
Microsoft Visual C++ 14.X:
    Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
    Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
    Microsoft Visual Studio Build Tools 2019 (x86, x64, arm, arm64)

This may also support compilers shipped with compatible Visual Studio versions.
"""

import json
from io import open
from os import listdir, pathsep
from os.path import join, isfile, isdir, dirname
from subprocess import CalledProcessError
import contextlib
import platform
import itertools
import subprocess
import distutils.errors
from setuptools.extern.more_itertools import unique_everseen

if platform.system() == 'Windows':
    import winreg
    from os import environ
else:
    # Mock winreg and environ so the module can be imported on this platform.

    class winreg:
        HKEY_USERS = None
        HKEY_CURRENT_USER = None
        HKEY_LOCAL_MACHINE = None
        HKEY_CLASSES_ROOT = None

    environ = dict()


def _msvc14_find_vc2015():
    """Python 3.8 "distutils/_msvccompiler.py" backport"""
    try:
        key = winreg.OpenKey(
            winreg.HKEY_LOCAL_MACHINE,
            r"Software\Microsoft\VisualStudio\SxS\VC7",
            0,
            winreg.KEY_READ | winreg.KEY_WOW64_32KEY,
        )
    except OSError:
        return None, None

    best_version = 0
    best_dir = None
    with key:
        for i in itertools.count():
            try:
                v, vc_dir, vt = winreg.EnumValue(key, i)
            except OSError:
                break
            if v and vt == winreg.REG_SZ and isdir(vc_dir):
                try:
                    version = int(float(v))
                except (ValueError, TypeError):
                    continue
                if version >= 14 and version > best_version:
                    best_version, best_dir = version, vc_dir
    return best_version, best_dir


def _msvc14_find_vc2017():
    """Python 3.8 "distutils/_msvccompiler.py" backport

    Returns "15, path" based on the result of invoking vswhere.exe
    If no install is found, returns "None, None"

    The version is returned to avoid unnecessarily changing the function
    result. It may be ignored when the path is not None.

    If vswhere.exe is not available, by definition, VS 2017 is not
    installed.
    """
    root = environ.get("ProgramFiles(x86)") or environ.get("ProgramFiles")
    if not root:
        return None, None

    suitable_components = (
        "Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
        "Microsoft.VisualStudio.Workload.WDExpress",
    )

    for component in suitable_components:
        # Workaround for `-requiresAny` (only available on VS 2017 > 15.6)
        with contextlib.suppress(CalledProcessError, OSError, UnicodeDecodeError):
            path = (
                subprocess.check_output(
                    [
                        join(
                            root, "Microsoft Visual Studio", "Installer", "vswhere.exe"
                        ),
                        "-latest",
                        "-prerelease",
                        "-requires",
                        component,
                        "-property",
                        "installationPath",
                        "-products",
                        "*",
                    ]
                )
                .decode(encoding="mbcs", errors="strict")
                .strip()
            )

            path = join(path, "VC", "Auxiliary", "Build")
            if isdir(path):
                return 15, path

    return None, None  # no suitable component found


PLAT_SPEC_TO_RUNTIME = {
    'x86': 'x86',
    'x86_amd64': 'x64',
    'x86_arm': 'arm',
    'x86_arm64': 'arm64',
}


def _msvc14_find_vcvarsall(plat_spec):
    """Python 3.8 "distutils/_msvccompiler.py" backport"""
    _, best_dir = _msvc14_find_vc2017()
    vcruntime = None

    if plat_spec in PLAT_SPEC_TO_RUNTIME:
        vcruntime_plat = PLAT_SPEC_TO_RUNTIME[plat_spec]
    else:
        vcruntime_plat = 'x64' if 'amd64' in plat_spec else 'x86'

    if best_dir:
        vcredist = join(
            best_dir,
            "..",
            "..",
            "redist",
            "MSVC",
            "**",
            vcruntime_plat,
            "Microsoft.VC14*.CRT",
            "vcruntime140.dll",
        )
        try:
            import glob

            vcruntime = glob.glob(vcredist, recursive=True)[-1]
        except (ImportError, OSError, LookupError):
            vcruntime = None

    if not best_dir:
        best_version, best_dir = _msvc14_find_vc2015()
        if best_version:
            vcruntime = join(
                best_dir,
                'redist',
                vcruntime_plat,
                "Microsoft.VC140.CRT",
                "vcruntime140.dll",
            )

    if not best_dir:
        return None, None

    vcvarsall = join(best_dir, "vcvarsall.bat")
    if not isfile(vcvarsall):
        return None, None

    if not vcruntime or not isfile(vcruntime):
        vcruntime = None

    return vcvarsall, vcruntime


def _msvc14_get_vc_env(plat_spec):
    """Python 3.8 "distutils/_msvccompiler.py" backport"""
    if "DISTUTILS_USE_SDK" in environ:
        return {key.lower(): value for key, value in environ.items()}

    vcvarsall, vcruntime = _msvc14_find_vcvarsall(plat_spec)
    if not vcvarsall:
        raise distutils.errors.DistutilsPlatformError("Unable to find vcvarsall.bat")

    try:
        out = subprocess.check_output(
            'cmd /u /c "{}" {} && set'.format(vcvarsall, plat_spec),
            stderr=subprocess.STDOUT,
        ).decode('utf-16le', errors='replace')
    except subprocess.CalledProcessError as exc:
        raise distutils.errors.DistutilsPlatformError(
            "Error executing {}".format(exc.cmd)
        ) from exc

    env = {
        key.lower(): value
        for key, _, value in (line.partition('=') for line in out.splitlines())
        if key and value
    }

    if vcruntime:
        env['py_vcruntime_redist'] = vcruntime
    return env


def msvc14_get_vc_env(plat_spec):
    """
    Patched "distutils._msvccompiler._get_vc_env" for support extra
    Microsoft Visual C++ 14.X compilers.

    Set environment without use of "vcvarsall.bat".

    Parameters
    ----------
    plat_spec: str
        Target architecture.

    Return
    ------
    dict
        environment
    """

    # Always use backport from CPython 3.8
    try:
        return _msvc14_get_vc_env(plat_spec)
    except distutils.errors.DistutilsPlatformError as exc:
        _augment_exception(exc, 14.0)
        raise


def _augment_exception(exc, version, arch=''):
    """
    Add details to the exception message to help guide the user
    as to what action will resolve it.
    """
    # Error if MSVC++ directory not found or environment not set
    message = exc.args[0]

    if "vcvarsall" in message.lower() or "visual c" in message.lower():
        # Special error message if MSVC++ not installed
        tmpl = 'Microsoft Visual C++ {version:0.1f} or greater is required.'
        message = tmpl.format(**locals())
        msdownload = 'www.microsoft.com/download/details.aspx?id=%d'
        if version == 9.0:
            if arch.lower().find('ia64') > -1:
                # For VC++ 9.0, if IA64 support is needed, redirect user
                # to Windows SDK 7.0.
                # Note: No download link available from Microsoft.
                message += ' Get it with "Microsoft Windows SDK 7.0"'
            else:
                # For VC++ 9.0 redirect user to Vc++ for Python 2.7 :
                # This redirection link is maintained by Microsoft.
                # Contact vspython@microsoft.com if it needs updating.
                message += ' Get it from http://aka.ms/vcpython27'
        elif version == 10.0:
            # For VC++ 10.0 Redirect user to Windows SDK 7.1
            message += ' Get it with "Microsoft Windows SDK 7.1": '
            message += msdownload % 8279
        elif version >= 14.0:
            # For VC++ 14.X Redirect user to latest Visual C++ Build Tools
            message += (
                ' Get it with "Microsoft C++ Build Tools": '
                r'https://visualstudio.microsoft.com'
                r'/visual-cpp-build-tools/'
            )

    exc.args = (message,)


class PlatformInfo:
    """
    Current and Target Architectures information.

    Parameters
    ----------
    arch: str
        Target architecture.
    """

    current_cpu = environ.get('processor_architecture', '').lower()

    def __init__(self, arch):
        self.arch = arch.lower().replace('x64', 'amd64')

    @property
    def target_cpu(self):
        """
        Return Target CPU architecture.

        Return
        ------
        str
            Target CPU
        """
        return self.arch[self.arch.find('_') + 1 :]

    def target_is_x86(self):
        """
        Return True if target CPU is x86 32 bits..

        Return
        ------
        bool
            CPU is x86 32 bits
        """
        return self.target_cpu == 'x86'

    def current_is_x86(self):
        """
        Return True if current CPU is x86 32 bits..

        Return
        ------
        bool
            CPU is x86 32 bits
        """
        return self.current_cpu == 'x86'

    def current_dir(self, hidex86=False, x64=False):
        """
        Current platform specific subfolder.

        Parameters
        ----------
        hidex86: bool
            return '' and not '\x86' if architecture is x86.
        x64: bool
            return '\x64' and not '\amd64' if architecture is amd64.

        Return
        ------
        str
            subfolder: '\target', or '' (see hidex86 parameter)
        """
        return (
            ''
            if (self.current_cpu == 'x86' and hidex86)
            else r'\x64'
            if (self.current_cpu == 'amd64' and x64)
            else r'\%s' % self.current_cpu
        )

    def target_dir(self, hidex86=False, x64=False):
        r"""
        Target platform specific subfolder.

        Parameters
        ----------
        hidex86: bool
            return '' and not '\x86' if architecture is x86.
        x64: bool
            return '\x64' and not '\amd64' if architecture is amd64.

        Return
        ------
        str
            subfolder: '\current', or '' (see hidex86 parameter)
        """
        return (
            ''
            if (self.target_cpu == 'x86' and hidex86)
            else r'\x64'
            if (self.target_cpu == 'amd64' and x64)
            else r'\%s' % self.target_cpu
        )

    def cross_dir(self, forcex86=False):
        r"""
        Cross platform specific subfolder.

        Parameters
        ----------
        forcex86: bool
            Use 'x86' as current architecture even if current architecture is
            not x86.

        Return
        ------
        str
            subfolder: '' if target architecture is current architecture,
            '\current_target' if not.
        """
        current = 'x86' if forcex86 else self.current_cpu
        return (
            ''
            if self.target_cpu == current
            else self.target_dir().replace('\\', '\\%s_' % current)
        )


class RegistryInfo:
    """
    Microsoft Visual Studio related registry information.

    Parameters
    ----------
    platform_info: PlatformInfo
        "PlatformInfo" instance.
    """

    HKEYS = (
        winreg.HKEY_USERS,
        winreg.HKEY_CURRENT_USER,
        winreg.HKEY_LOCAL_MACHINE,
        winreg.HKEY_CLASSES_ROOT,
    )

    def __init__(self, platform_info):
        self.pi = platform_info

    @property
    def visualstudio(self):
        """
        Microsoft Visual Studio root registry key.

        Return
        ------
        str
            Registry key
        """
        return 'VisualStudio'

    @property
    def sxs(self):
        """
        Microsoft Visual Studio SxS registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.visualstudio, 'SxS')

    @property
    def vc(self):
        """
        Microsoft Visual C++ VC7 registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.sxs, 'VC7')

    @property
    def vs(self):
        """
        Microsoft Visual Studio VS7 registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.sxs, 'VS7')

    @property
    def vc_for_python(self):
        """
        Microsoft Visual C++ for Python registry key.

        Return
        ------
        str
            Registry key
        """
        return r'DevDiv\VCForPython'

    @property
    def microsoft_sdk(self):
        """
        Microsoft SDK registry key.

        Return
        ------
        str
            Registry key
        """
        return 'Microsoft SDKs'

    @property
    def windows_sdk(self):
        """
        Microsoft Windows/Platform SDK registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.microsoft_sdk, 'Windows')

    @property
    def netfx_sdk(self):
        """
        Microsoft .NET Framework SDK registry key.

        Return
        ------
        str
            Registry key
        """
        return join(self.microsoft_sdk, 'NETFXSDK')

    @property
    def windows_kits_roots(self):
        """
        Microsoft Windows Kits Roots registry key.

        Return
        ------
        str
            Registry key
        """
        return r'Windows Kits\Installed Roots'

    def microsoft(self, key, x86=False):
        """
        Return key in Microsoft software registry.

        Parameters
        ----------
        key: str
            Registry key path where look.
        x86: str
            Force x86 software registry.

        Return
        ------
        str
            Registry key
        """
        node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node'
        return join('Software', node64, 'Microsoft', key)

    def lookup(self, key, name):
        """
        Look for values in registry in Microsoft software registry.

        Parameters
        ----------
        key: str
            Registry key path where look.
        name: str
            Value name to find.

        Return
        ------
        str
            value
        """
        key_read = winreg.KEY_READ
        openkey = winreg.OpenKey
        closekey = winreg.CloseKey
        ms = self.microsoft
        for hkey in self.HKEYS:
            bkey = None
            try:
                bkey = openkey(hkey, ms(key), 0, key_read)
            except (OSError, IOError):
                if not self.pi.current_is_x86():
                    try:
                        bkey = openkey(hkey, ms(key, True), 0, key_read)
                    except (OSError, IOError):
                        continue
                else:
                    continue
            try:
                return winreg.QueryValueEx(bkey, name)[0]
            except (OSError, IOError):
                pass
            finally:
                if bkey:
                    closekey(bkey)


class SystemInfo:
    """
    Microsoft Windows and Visual Studio related system information.

    Parameters
    ----------
    registry_info: RegistryInfo
        "RegistryInfo" instance.
    vc_ver: float
        Required Microsoft Visual C++ version.
    """

    # Variables and properties in this class use originals CamelCase variables
    # names from Microsoft source files for more easy comparison.
    WinDir = environ.get('WinDir', '')
    ProgramFiles = environ.get('ProgramFiles', '')
    ProgramFilesx86 = environ.get('ProgramFiles(x86)', ProgramFiles)

    def __init__(self, registry_info, vc_ver=None):
        self.ri = registry_info
        self.pi = self.ri.pi

        self.known_vs_paths = self.find_programdata_vs_vers()

        # Except for VS15+, VC version is aligned with VS version
        self.vs_ver = self.vc_ver = vc_ver or self._find_latest_available_vs_ver()

    def _find_latest_available_vs_ver(self):
        """
        Find the latest VC version

        Return
        ------
        float
            version
        """
        reg_vc_vers = self.find_reg_vs_vers()

        if not (reg_vc_vers or self.known_vs_paths):
            raise distutils.errors.DistutilsPlatformError(
                'No Microsoft Visual C++ version found'
            )

        vc_vers = set(reg_vc_vers)
        vc_vers.update(self.known_vs_paths)
        return sorted(vc_vers)[-1]

    def find_reg_vs_vers(self):
        """
        Find Microsoft Visual Studio versions available in registry.

        Return
        ------
        list of float
            Versions
        """
        ms = self.ri.microsoft
        vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs)
        vs_vers = []
        for hkey, key in itertools.product(self.ri.HKEYS, vckeys):
            try:
                bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ)
            except (OSError, IOError):
                continue
            with bkey:
                subkeys, values, _ = winreg.QueryInfoKey(bkey)
                for i in range(values):
                    with contextlib.suppress(ValueError):
                        ver = float(winreg.EnumValue(bkey, i)[0])
                        if ver not in vs_vers:
                            vs_vers.append(ver)
                for i in range(subkeys):
                    with contextlib.suppress(ValueError):
                        ver = float(winreg.EnumKey(bkey, i))
                        if ver not in vs_vers:
                            vs_vers.append(ver)
        return sorted(vs_vers)

    def find_programdata_vs_vers(self):
        r"""
        Find Visual studio 2017+ versions from information in
        "C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances".

        Return
        ------
        dict
            float version as key, path as value.
        """
        vs_versions = {}
        instances_dir = r'C:\ProgramData\Microsoft\VisualStudio\Packages\_Instances'

        try:
            hashed_names = listdir(instances_dir)

        except (OSError, IOError):
            # Directory not exists with all Visual Studio versions
            return vs_versions

        for name in hashed_names:
            try:
                # Get VS installation path from "state.json" file
                state_path = join(instances_dir, name, 'state.json')
                with open(state_path, 'rt', encoding='utf-8') as state_file:
                    state = json.load(state_file)
                vs_path = state['installationPath']

                # Raises OSError if this VS installation does not contain VC
                listdir(join(vs_path, r'VC\Tools\MSVC'))

                # Store version and path
                vs_versions[
                    self._as_float_version(state['installationVersion'])
                ] = vs_path

            except (OSError, IOError, KeyError):
                # Skip if "state.json" file is missing or bad format
                continue

        return vs_versions

    @staticmethod
    def _as_float_version(version):
        """
        Return a string version as a simplified float version (major.minor)

        Parameters
        ----------
        version: str
            Version.

        Return
        ------
        float
            version
        """
        return float('.'.join(version.split('.')[:2]))

    @property
    def VSInstallDir(self):
        """
        Microsoft Visual Studio directory.

        Return
        ------
        str
            path
        """
        # Default path
        default = join(
            self.ProgramFilesx86, 'Microsoft Visual Studio %0.1f' % self.vs_ver
        )

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vs, '%0.1f' % self.vs_ver) or default

    @property
    def VCInstallDir(self):
        """
        Microsoft Visual C++ directory.

        Return
        ------
        str
            path
        """
        path = self._guess_vc() or self._guess_vc_legacy()

        if not isdir(path):
            msg = 'Microsoft Visual C++ directory not found'
            raise distutils.errors.DistutilsPlatformError(msg)

        return path

    def _guess_vc(self):
        """
        Locate Visual C++ for VS2017+.

        Return
        ------
        str
            path
        """
        if self.vs_ver <= 14.0:
            return ''

        try:
            # First search in known VS paths
            vs_dir = self.known_vs_paths[self.vs_ver]
        except KeyError:
            # Else, search with path from registry
            vs_dir = self.VSInstallDir

        guess_vc = join(vs_dir, r'VC\Tools\MSVC')

        # Subdir with VC exact version as name
        try:
            # Update the VC version with real one instead of VS version
            vc_ver = listdir(guess_vc)[-1]
            self.vc_ver = self._as_float_version(vc_ver)
            return join(guess_vc, vc_ver)
        except (OSError, IOError, IndexError):
            return ''

    def _guess_vc_legacy(self):
        """
        Locate Visual C++ for versions prior to 2017.

        Return
        ------
        str
            path
        """
        default = join(
            self.ProgramFilesx86, r'Microsoft Visual Studio %0.1f\VC' % self.vs_ver
        )

        # Try to get "VC++ for Python" path from registry as default path
        reg_path = join(self.ri.vc_for_python, '%0.1f' % self.vs_ver)
        python_vc = self.ri.lookup(reg_path, 'installdir')
        default_vc = join(python_vc, 'VC') if python_vc else default

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, '%0.1f' % self.vs_ver) or default_vc

    @property
    def WindowsSdkVersion(self):
        """
        Microsoft Windows SDK versions for specified MSVC++ version.

        Return
        ------
        tuple of str
            versions
        """
        if self.vs_ver <= 9.0:
            return '7.0', '6.1', '6.0a'
        elif self.vs_ver == 10.0:
            return '7.1', '7.0a'
        elif self.vs_ver == 11.0:
            return '8.0', '8.0a'
        elif self.vs_ver == 12.0:
            return '8.1', '8.1a'
        elif self.vs_ver >= 14.0:
            return '10.0', '8.1'

    @property
    def WindowsSdkLastVersion(self):
        """
        Microsoft Windows SDK last version.

        Return
        ------
        str
            version
        """
        return self._use_last_dir_name(join(self.WindowsSdkDir, 'lib'))

    @property  # noqa: C901
    def WindowsSdkDir(self):  # noqa: C901  # is too complex (12)  # FIXME
        """
        Microsoft Windows SDK directory.

        Return
        ------
        str
            path
        """
        sdkdir = ''
        for ver in self.WindowsSdkVersion:
            # Try to get it from registry
            loc = join(self.ri.windows_sdk, 'v%s' % ver)
            sdkdir = self.ri.lookup(loc, 'installationfolder')
            if sdkdir:
                break
        if not sdkdir or not isdir(sdkdir):
            # Try to get "VC++ for Python" version from registry
            path = join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
            install_base = self.ri.lookup(path, 'installdir')
            if install_base:
                sdkdir = join(install_base, 'WinSDK')
        if not sdkdir or not isdir(sdkdir):
            # If fail, use default new path
            for ver in self.WindowsSdkVersion:
                intver = ver[: ver.rfind('.')]
                path = r'Microsoft SDKs\Windows Kits\%s' % intver
                d = join(self.ProgramFiles, path)
                if isdir(d):
                    sdkdir = d
        if not sdkdir or not isdir(sdkdir):
            # If fail, use default old path
            for ver in self.WindowsSdkVersion:
                path = r'Microsoft SDKs\Windows\v%s' % ver
                d = join(self.ProgramFiles, path)
                if isdir(d):
                    sdkdir = d
        if not sdkdir:
            # If fail, use Platform SDK
            sdkdir = join(self.VCInstallDir, 'PlatformSDK')
        return sdkdir

    @property
    def WindowsSDKExecutablePath(self):
        """
        Microsoft Windows SDK executable directory.

        Return
        ------
        str
            path
        """
        # Find WinSDK NetFx Tools registry dir name
        if self.vs_ver <= 11.0:
            netfxver = 35
            arch = ''
        else:
            netfxver = 40
            hidex86 = True if self.vs_ver <= 12.0 else False
            arch = self.pi.current_dir(x64=True, hidex86=hidex86)
        fx = 'WinSDK-NetFx%dTools%s' % (netfxver, arch.replace('\\', '-'))

        # list all possibles registry paths
        regpaths = []
        if self.vs_ver >= 14.0:
            for ver in self.NetFxSdkVersion:
                regpaths += [join(self.ri.netfx_sdk, ver, fx)]

        for ver in self.WindowsSdkVersion:
            regpaths += [join(self.ri.windows_sdk, 'v%sA' % ver, fx)]

        # Return installation folder from the more recent path
        for path in regpaths:
            execpath = self.ri.lookup(path, 'installationfolder')
            if execpath:
                return execpath

    @property
    def FSharpInstallDir(self):
        """
        Microsoft Visual F# directory.

        Return
        ------
        str
            path
        """
        path = join(self.ri.visualstudio, r'%0.1f\Setup\F#' % self.vs_ver)
        return self.ri.lookup(path, 'productdir') or ''

    @property
    def UniversalCRTSdkDir(self):
        """
        Microsoft Universal CRT SDK directory.

        Return
        ------
        str
            path
        """
        # Set Kit Roots versions for specified MSVC++ version
        vers = ('10', '81') if self.vs_ver >= 14.0 else ()

        # Find path of the more recent Kit
        for ver in vers:
            sdkdir = self.ri.lookup(self.ri.windows_kits_roots, 'kitsroot%s' % ver)
            if sdkdir:
                return sdkdir or ''

    @property
    def UniversalCRTSdkLastVersion(self):
        """
        Microsoft Universal C Runtime SDK last version.

        Return
        ------
        str
            version
        """
        return self._use_last_dir_name(join(self.UniversalCRTSdkDir, 'lib'))

    @property
    def NetFxSdkVersion(self):
        """
        Microsoft .NET Framework SDK versions.

        Return
        ------
        tuple of str
            versions
        """
        # Set FxSdk versions for specified VS version
        return (
            ('4.7.2', '4.7.1', '4.7', '4.6.2', '4.6.1', '4.6', '4.5.2', '4.5.1', '4.5')
            if self.vs_ver >= 14.0
            else ()
        )

    @property
    def NetFxSdkDir(self):
        """
        Microsoft .NET Framework SDK directory.

        Return
        ------
        str
            path
        """
        sdkdir = ''
        for ver in self.NetFxSdkVersion:
            loc = join(self.ri.netfx_sdk, ver)
            sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder')
            if sdkdir:
                break
        return sdkdir

    @property
    def FrameworkDir32(self):
        """
        Microsoft .NET Framework 32bit directory.

        Return
        ------
        str
            path
        """
        # Default path
        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework')

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw

    @property
    def FrameworkDir64(self):
        """
        Microsoft .NET Framework 64bit directory.

        Return
        ------
        str
            path
        """
        # Default path
        guess_fw = join(self.WinDir, r'Microsoft.NET\Framework64')

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw

    @property
    def FrameworkVersion32(self):
        """
        Microsoft .NET Framework 32bit versions.

        Return
        ------
        tuple of str
            versions
        """
        return self._find_dot_net_versions(32)

    @property
    def FrameworkVersion64(self):
        """
        Microsoft .NET Framework 64bit versions.

        Return
        ------
        tuple of str
            versions
        """
        return self._find_dot_net_versions(64)

    def _find_dot_net_versions(self, bits):
        """
        Find Microsoft .NET Framework versions.

        Parameters
        ----------
        bits: int
            Platform number of bits: 32 or 64.

        Return
        ------
        tuple of str
            versions
        """
        # Find actual .NET version in registry
        reg_ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits)
        dot_net_dir = getattr(self, 'FrameworkDir%d' % bits)
        ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or ''

        # Set .NET versions for specified MSVC++ version
        if self.vs_ver >= 12.0:
            return ver, 'v4.0'
        elif self.vs_ver >= 10.0:
            return 'v4.0.30319' if ver.lower()[:2] != 'v4' else ver, 'v3.5'
        elif self.vs_ver == 9.0:
            return 'v3.5', 'v2.0.50727'
        elif self.vs_ver == 8.0:
            return 'v3.0', 'v2.0.50727'

    @staticmethod
    def _use_last_dir_name(path, prefix=''):
        """
        Return name of the last dir in path or '' if no dir found.

        Parameters
        ----------
        path: str
            Use dirs in this path
        prefix: str
            Use only dirs starting by this prefix

        Return
        ------
        str
            name
        """
        matching_dirs = (
            dir_name
            for dir_name in reversed(listdir(path))
            if isdir(join(path, dir_name)) and dir_name.startswith(prefix)
        )
        return next(matching_dirs, None) or ''


class EnvironmentInfo:
    """
    Return environment variables for specified Microsoft Visual C++ version
    and platform : Lib, Include, Path and libpath.

    This function is compatible with Microsoft Visual C++ 9.0 to 14.X.

    Script created by analysing Microsoft environment configuration files like
    "vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...

    Parameters
    ----------
    arch: str
        Target architecture.
    vc_ver: float
        Required Microsoft Visual C++ version. If not set, autodetect the last
        version.
    vc_min_ver: float
        Minimum Microsoft Visual C++ version.
    """

    # Variables and properties in this class use originals CamelCase variables
    # names from Microsoft source files for more easy comparison.

    def __init__(self, arch, vc_ver=None, vc_min_ver=0):
        self.pi = PlatformInfo(arch)
        self.ri = RegistryInfo(self.pi)
        self.si = SystemInfo(self.ri, vc_ver)

        if self.vc_ver < vc_min_ver:
            err = 'No suitable Microsoft Visual C++ version found'
            raise distutils.errors.DistutilsPlatformError(err)

    @property
    def vs_ver(self):
        """
        Microsoft Visual Studio.

        Return
        ------
        float
            version
        """
        return self.si.vs_ver

    @property
    def vc_ver(self):
        """
        Microsoft Visual C++ version.

        Return
        ------
        float
            version
        """
        return self.si.vc_ver

    @property
    def VSTools(self):
        """
        Microsoft Visual Studio Tools.

        Return
        ------
        list of str
            paths
        """
        paths = [r'Common7\IDE', r'Common7\Tools']

        if self.vs_ver >= 14.0:
            arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
            paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow']
            paths += [r'Team Tools\Performance Tools']
            paths += [r'Team Tools\Performance Tools%s' % arch_subdir]

        return [join(self.si.VSInstallDir, path) for path in paths]

    @property
    def VCIncludes(self):
        """
        Microsoft Visual C++ & Microsoft Foundation Class Includes.

        Return
        ------
        list of str
            paths
        """
        return [
            join(self.si.VCInstallDir, 'Include'),
            join(self.si.VCInstallDir, r'ATLMFC\Include'),
        ]

    @property
    def VCLibraries(self):
        """
        Microsoft Visual C++ & Microsoft Foundation Class Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver >= 15.0:
            arch_subdir = self.pi.target_dir(x64=True)
        else:
            arch_subdir = self.pi.target_dir(hidex86=True)
        paths = ['Lib%s' % arch_subdir, r'ATLMFC\Lib%s' % arch_subdir]

        if self.vs_ver >= 14.0:
            paths += [r'Lib\store%s' % arch_subdir]

        return [join(self.si.VCInstallDir, path) for path in paths]

    @property
    def VCStoreRefs(self):
        """
        Microsoft Visual C++ store references Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0:
            return []
        return [join(self.si.VCInstallDir, r'Lib\store\references')]

    @property
    def VCTools(self):
        """
        Microsoft Visual C++ Tools.

        Return
        ------
        list of str
            paths
        """
        si = self.si
        tools = [join(si.VCInstallDir, 'VCPackages')]

        forcex86 = True if self.vs_ver <= 10.0 else False
        arch_subdir = self.pi.cross_dir(forcex86)
        if arch_subdir:
            tools += [join(si.VCInstallDir, 'Bin%s' % arch_subdir)]

        if self.vs_ver == 14.0:
            path = 'Bin%s' % self.pi.current_dir(hidex86=True)
            tools += [join(si.VCInstallDir, path)]

        elif self.vs_ver >= 15.0:
            host_dir = (
                r'bin\HostX86%s' if self.pi.current_is_x86() else r'bin\HostX64%s'
            )
            tools += [join(si.VCInstallDir, host_dir % self.pi.target_dir(x64=True))]

            if self.pi.current_cpu != self.pi.target_cpu:
                tools += [
                    join(si.VCInstallDir, host_dir % self.pi.current_dir(x64=True))
                ]

        else:
            tools += [join(si.VCInstallDir, 'Bin')]

        return tools

    @property
    def OSLibraries(self):
        """
        Microsoft Windows SDK Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver <= 10.0:
            arch_subdir = self.pi.target_dir(hidex86=True, x64=True)
            return [join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)]

        else:
            arch_subdir = self.pi.target_dir(x64=True)
            lib = join(self.si.WindowsSdkDir, 'lib')
            libver = self._sdk_subdir
            return [join(lib, '%sum%s' % (libver, arch_subdir))]

    @property
    def OSIncludes(self):
        """
        Microsoft Windows SDK Include.

        Return
        ------
        list of str
            paths
        """
        include = join(self.si.WindowsSdkDir, 'include')

        if self.vs_ver <= 10.0:
            return [include, join(include, 'gl')]

        else:
            if self.vs_ver >= 14.0:
                sdkver = self._sdk_subdir
            else:
                sdkver = ''
            return [
                join(include, '%sshared' % sdkver),
                join(include, '%sum' % sdkver),
                join(include, '%swinrt' % sdkver),
            ]

    @property
    def OSLibpath(self):
        """
        Microsoft Windows SDK Libraries Paths.

        Return
        ------
        list of str
            paths
        """
        ref = join(self.si.WindowsSdkDir, 'References')
        libpath = []

        if self.vs_ver <= 9.0:
            libpath += self.OSLibraries

        if self.vs_ver >= 11.0:
            libpath += [join(ref, r'CommonConfiguration\Neutral')]

        if self.vs_ver >= 14.0:
            libpath += [
                ref,
                join(self.si.WindowsSdkDir, 'UnionMetadata'),
                join(ref, 'Windows.Foundation.UniversalApiContract', '1.0.0.0'),
                join(ref, 'Windows.Foundation.FoundationContract', '1.0.0.0'),
                join(ref, 'Windows.Networking.Connectivity.WwanContract', '1.0.0.0'),
                join(
                    self.si.WindowsSdkDir,
                    'ExtensionSDKs',
                    'Microsoft.VCLibs',
                    '%0.1f' % self.vs_ver,
                    'References',
                    'CommonConfiguration',
                    'neutral',
                ),
            ]
        return libpath

    @property
    def SdkTools(self):
        """
        Microsoft Windows SDK Tools.

        Return
        ------
        list of str
            paths
        """
        return list(self._sdk_tools())

    def _sdk_tools(self):
        """
        Microsoft Windows SDK Tools paths generator.

        Return
        ------
        generator of str
            paths
        """
        if self.vs_ver < 15.0:
            bin_dir = 'Bin' if self.vs_ver <= 11.0 else r'Bin\x86'
            yield join(self.si.WindowsSdkDir, bin_dir)

        if not self.pi.current_is_x86():
            arch_subdir = self.pi.current_dir(x64=True)
            path = 'Bin%s' % arch_subdir
            yield join(self.si.WindowsSdkDir, path)

        if self.vs_ver in (10.0, 11.0):
            if self.pi.target_is_x86():
                arch_subdir = ''
            else:
                arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
            path = r'Bin\NETFX 4.0 Tools%s' % arch_subdir
            yield join(self.si.WindowsSdkDir, path)

        elif self.vs_ver >= 15.0:
            path = join(self.si.WindowsSdkDir, 'Bin')
            arch_subdir = self.pi.current_dir(x64=True)
            sdkver = self.si.WindowsSdkLastVersion
            yield join(path, '%s%s' % (sdkver, arch_subdir))

        if self.si.WindowsSDKExecutablePath:
            yield self.si.WindowsSDKExecutablePath

    @property
    def _sdk_subdir(self):
        """
        Microsoft Windows SDK version subdir.

        Return
        ------
        str
            subdir
        """
        ucrtver = self.si.WindowsSdkLastVersion
        return ('%s\\' % ucrtver) if ucrtver else ''

    @property
    def SdkSetup(self):
        """
        Microsoft Windows SDK Setup.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver > 9.0:
            return []

        return [join(self.si.WindowsSdkDir, 'Setup')]

    @property
    def FxTools(self):
        """
        Microsoft .NET Framework Tools.

        Return
        ------
        list of str
            paths
        """
        pi = self.pi
        si = self.si

        if self.vs_ver <= 10.0:
            include32 = True
            include64 = not pi.target_is_x86() and not pi.current_is_x86()
        else:
            include32 = pi.target_is_x86() or pi.current_is_x86()
            include64 = pi.current_cpu == 'amd64' or pi.target_cpu == 'amd64'

        tools = []
        if include32:
            tools += [join(si.FrameworkDir32, ver) for ver in si.FrameworkVersion32]
        if include64:
            tools += [join(si.FrameworkDir64, ver) for ver in si.FrameworkVersion64]
        return tools

    @property
    def NetFxSDKLibraries(self):
        """
        Microsoft .Net Framework SDK Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
            return []

        arch_subdir = self.pi.target_dir(x64=True)
        return [join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)]

    @property
    def NetFxSDKIncludes(self):
        """
        Microsoft .Net Framework SDK Includes.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0 or not self.si.NetFxSdkDir:
            return []

        return [join(self.si.NetFxSdkDir, r'include\um')]

    @property
    def VsTDb(self):
        """
        Microsoft Visual Studio Team System Database.

        Return
        ------
        list of str
            paths
        """
        return [join(self.si.VSInstallDir, r'VSTSDB\Deploy')]

    @property
    def MSBuild(self):
        """
        Microsoft Build Engine.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 12.0:
            return []
        elif self.vs_ver < 15.0:
            base_path = self.si.ProgramFilesx86
            arch_subdir = self.pi.current_dir(hidex86=True)
        else:
            base_path = self.si.VSInstallDir
            arch_subdir = ''

        path = r'MSBuild\%0.1f\bin%s' % (self.vs_ver, arch_subdir)
        build = [join(base_path, path)]

        if self.vs_ver >= 15.0:
            # Add Roslyn C# & Visual Basic Compiler
            build += [join(base_path, path, 'Roslyn')]

        return build

    @property
    def HTMLHelpWorkshop(self):
        """
        Microsoft HTML Help Workshop.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 11.0:
            return []

        return [join(self.si.ProgramFilesx86, 'HTML Help Workshop')]

    @property
    def UCRTLibraries(self):
        """
        Microsoft Universal C Runtime SDK Libraries.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0:
            return []

        arch_subdir = self.pi.target_dir(x64=True)
        lib = join(self.si.UniversalCRTSdkDir, 'lib')
        ucrtver = self._ucrt_subdir
        return [join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]

    @property
    def UCRTIncludes(self):
        """
        Microsoft Universal C Runtime SDK Include.

        Return
        ------
        list of str
            paths
        """
        if self.vs_ver < 14.0:
            return []

        include = join(self.si.UniversalCRTSdkDir, 'include')
        return [join(include, '%sucrt' % self._ucrt_subdir)]

    @property
    def _ucrt_subdir(self):
        """
        Microsoft Universal C Runtime SDK version subdir.

        Return
        ------
        str
            subdir
        """
        ucrtver = self.si.UniversalCRTSdkLastVersion
        return ('%s\\' % ucrtver) if ucrtver else ''

    @property
    def FSharp(self):
        """
        Microsoft Visual F#.

        Return
        ------
        list of str
            paths
        """
        if 11.0 > self.vs_ver > 12.0:
            return []

        return [self.si.FSharpInstallDir]

    @property
    def VCRuntimeRedist(self):
        """
        Microsoft Visual C++ runtime redistributable dll.

        Return
        ------
        str
            path
        """
        vcruntime = 'vcruntime%d0.dll' % self.vc_ver
        arch_subdir = self.pi.target_dir(x64=True).strip('\\')

        # Installation prefixes candidates
        prefixes = []
        tools_path = self.si.VCInstallDir
        redist_path = dirname(tools_path.replace(r'\Tools', r'\Redist'))
        if isdir(redist_path):
            # Redist version may not be exactly the same as tools
            redist_path = join(redist_path, listdir(redist_path)[-1])
            prefixes += [redist_path, join(redist_path, 'onecore')]

        prefixes += [join(tools_path, 'redist')]  # VS14 legacy path

        # CRT directory
        crt_dirs = (
            'Microsoft.VC%d.CRT' % (self.vc_ver * 10),
            # Sometime store in directory with VS version instead of VC
            'Microsoft.VC%d.CRT' % (int(self.vs_ver) * 10),
        )

        # vcruntime path
        for prefix, crt_dir in itertools.product(prefixes, crt_dirs):
            path = join(prefix, arch_subdir, crt_dir, vcruntime)
            if isfile(path):
                return path

    def return_env(self, exists=True):
        """
        Return environment dict.

        Parameters
        ----------
        exists: bool
            It True, only return existing paths.

        Return
        ------
        dict
            environment
        """
        env = dict(
            include=self._build_paths(
                'include',
                [
                    self.VCIncludes,
                    self.OSIncludes,
                    self.UCRTIncludes,
                    self.NetFxSDKIncludes,
                ],
                exists,
            ),
            lib=self._build_paths(
                'lib',
                [
                    self.VCLibraries,
                    self.OSLibraries,
                    self.FxTools,
                    self.UCRTLibraries,
                    self.NetFxSDKLibraries,
                ],
                exists,
            ),
            libpath=self._build_paths(
                'libpath',
                [self.VCLibraries, self.FxTools, self.VCStoreRefs, self.OSLibpath],
                exists,
            ),
            path=self._build_paths(
                'path',
                [
                    self.VCTools,
                    self.VSTools,
                    self.VsTDb,
                    self.SdkTools,
                    self.SdkSetup,
                    self.FxTools,
                    self.MSBuild,
                    self.HTMLHelpWorkshop,
                    self.FSharp,
                ],
                exists,
            ),
        )
        if self.vs_ver >= 14 and isfile(self.VCRuntimeRedist):
            env['py_vcruntime_redist'] = self.VCRuntimeRedist
        return env

    def _build_paths(self, name, spec_path_lists, exists):
        """
        Given an environment variable name and specified paths,
        return a pathsep-separated string of paths containing
        unique, extant, directories from those paths and from
        the environment variable. Raise an error if no paths
        are resolved.

        Parameters
        ----------
        name: str
            Environment variable name
        spec_path_lists: list of str
            Paths
        exists: bool
            It True, only return existing paths.

        Return
        ------
        str
            Pathsep-separated paths
        """
        # flatten spec_path_lists
        spec_paths = itertools.chain.from_iterable(spec_path_lists)
        env_paths = environ.get(name, '').split(pathsep)
        paths = itertools.chain(spec_paths, env_paths)
        extant_paths = list(filter(isdir, paths)) if exists else paths
        if not extant_paths:
            msg = "%s environment variable is empty" % name.upper()
            raise distutils.errors.DistutilsPlatformError(msg)
        unique_paths = unique_everseen(extant_paths)
        return pathsep.join(unique_paths)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/namespaces.py0000644000175100001730000000574414467657412020376 0ustar00runnerdockerimport os
from distutils import log
import itertools


flatten = itertools.chain.from_iterable


class Installer:
    nspkg_ext = '-nspkg.pth'

    def install_namespaces(self):
        nsp = self._get_all_ns_packages()
        if not nsp:
            return
        filename, ext = os.path.splitext(self._get_target())
        filename += self.nspkg_ext
        self.outputs.append(filename)
        log.info("Installing %s", filename)
        lines = map(self._gen_nspkg_line, nsp)

        if self.dry_run:
            # always generate the lines, even in dry run
            list(lines)
            return

        with open(filename, 'wt') as f:
            f.writelines(lines)

    def uninstall_namespaces(self):
        filename, ext = os.path.splitext(self._get_target())
        filename += self.nspkg_ext
        if not os.path.exists(filename):
            return
        log.info("Removing %s", filename)
        os.remove(filename)

    def _get_target(self):
        return self.target

    _nspkg_tmpl = (
        "import sys, types, os",
        "has_mfs = sys.version_info > (3, 5)",
        "p = os.path.join(%(root)s, *%(pth)r)",
        "importlib = has_mfs and __import__('importlib.util')",
        "has_mfs and __import__('importlib.machinery')",
        (
            "m = has_mfs and "
            "sys.modules.setdefault(%(pkg)r, "
            "importlib.util.module_from_spec("
            "importlib.machinery.PathFinder.find_spec(%(pkg)r, "
            "[os.path.dirname(p)])))"
        ),
        ("m = m or " "sys.modules.setdefault(%(pkg)r, types.ModuleType(%(pkg)r))"),
        "mp = (m or []) and m.__dict__.setdefault('__path__',[])",
        "(p not in mp) and mp.append(p)",
    )
    "lines for the namespace installer"

    _nspkg_tmpl_multi = ('m and setattr(sys.modules[%(parent)r], %(child)r, m)',)
    "additional line(s) when a parent package is indicated"

    def _get_root(self):
        return "sys._getframe(1).f_locals['sitedir']"

    def _gen_nspkg_line(self, pkg):
        pth = tuple(pkg.split('.'))
        root = self._get_root()
        tmpl_lines = self._nspkg_tmpl
        parent, sep, child = pkg.rpartition('.')
        if parent:
            tmpl_lines += self._nspkg_tmpl_multi
        return ';'.join(tmpl_lines) % locals() + '\n'

    def _get_all_ns_packages(self):
        """Return sorted list of all package namespaces"""
        pkgs = self.distribution.namespace_packages or []
        return sorted(flatten(map(self._pkg_names, pkgs)))

    @staticmethod
    def _pkg_names(pkg):
        """
        Given a namespace package, yield the components of that
        package.

        >>> names = Installer._pkg_names('a.b.c')
        >>> set(names) == set(['a', 'a.b', 'a.b.c'])
        True
        """
        parts = pkg.split('.')
        while parts:
            yield '.'.join(parts)
            parts.pop()


class DevelopInstaller(Installer):
    def _get_root(self):
        return repr(str(self.egg_path))

    def _get_target(self):
        return self.egg_link
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/package_index.py0000644000175100001730000011271614467657412021037 0ustar00runnerdocker"""PyPI and direct package downloading."""

import sys
import os
import re
import io
import shutil
import socket
import base64
import hashlib
import itertools
import configparser
import html
import http.client
import urllib.parse
import urllib.request
import urllib.error
from functools import wraps

import setuptools
from pkg_resources import (
    CHECKOUT_DIST,
    Distribution,
    BINARY_DIST,
    normalize_path,
    SOURCE_DIST,
    Environment,
    find_distributions,
    safe_name,
    safe_version,
    to_filename,
    Requirement,
    DEVELOP_DIST,
    EGG_DIST,
    parse_version,
)
from distutils import log
from distutils.errors import DistutilsError
from fnmatch import translate
from setuptools.wheel import Wheel
from setuptools.extern.more_itertools import unique_everseen


EGG_FRAGMENT = re.compile(r'^egg=([-A-Za-z0-9_.+!]+)$')
HREF = re.compile(r"""href\s*=\s*['"]?([^'"> ]+)""", re.I)
PYPI_MD5 = re.compile(
    r'([^<]+)\n\s+\(md5\)'
)
URL_SCHEME = re.compile('([-+.a-z0-9]{2,}):', re.I).match
EXTENSIONS = ".tar.gz .tar.bz2 .tar .zip .tgz".split()

__all__ = [
    'PackageIndex',
    'distros_for_url',
    'parse_bdist_wininst',
    'interpret_distro_name',
]

_SOCKET_TIMEOUT = 15

_tmpl = "setuptools/{setuptools.__version__} Python-urllib/{py_major}"
user_agent = _tmpl.format(
    py_major='{}.{}'.format(*sys.version_info), setuptools=setuptools
)


def parse_requirement_arg(spec):
    try:
        return Requirement.parse(spec)
    except ValueError as e:
        raise DistutilsError(
            "Not a URL, existing file, or requirement spec: %r" % (spec,)
        ) from e


def parse_bdist_wininst(name):
    """Return (base,pyversion) or (None,None) for possible .exe name"""

    lower = name.lower()
    base, py_ver, plat = None, None, None

    if lower.endswith('.exe'):
        if lower.endswith('.win32.exe'):
            base = name[:-10]
            plat = 'win32'
        elif lower.startswith('.win32-py', -16):
            py_ver = name[-7:-4]
            base = name[:-16]
            plat = 'win32'
        elif lower.endswith('.win-amd64.exe'):
            base = name[:-14]
            plat = 'win-amd64'
        elif lower.startswith('.win-amd64-py', -20):
            py_ver = name[-7:-4]
            base = name[:-20]
            plat = 'win-amd64'
    return base, py_ver, plat


def egg_info_for_url(url):
    parts = urllib.parse.urlparse(url)
    scheme, server, path, parameters, query, fragment = parts
    base = urllib.parse.unquote(path.split('/')[-1])
    if server == 'sourceforge.net' and base == 'download':  # XXX Yuck
        base = urllib.parse.unquote(path.split('/')[-2])
    if '#' in base:
        base, fragment = base.split('#', 1)
    return base, fragment


def distros_for_url(url, metadata=None):
    """Yield egg or source distribution objects that might be found at a URL"""
    base, fragment = egg_info_for_url(url)
    for dist in distros_for_location(url, base, metadata):
        yield dist
    if fragment:
        match = EGG_FRAGMENT.match(fragment)
        if match:
            for dist in interpret_distro_name(
                url, match.group(1), metadata, precedence=CHECKOUT_DIST
            ):
                yield dist


def distros_for_location(location, basename, metadata=None):
    """Yield egg or source distribution objects based on basename"""
    if basename.endswith('.egg.zip'):
        basename = basename[:-4]  # strip the .zip
    if basename.endswith('.egg') and '-' in basename:
        # only one, unambiguous interpretation
        return [Distribution.from_location(location, basename, metadata)]
    if basename.endswith('.whl') and '-' in basename:
        wheel = Wheel(basename)
        if not wheel.is_compatible():
            return []
        return [
            Distribution(
                location=location,
                project_name=wheel.project_name,
                version=wheel.version,
                # Increase priority over eggs.
                precedence=EGG_DIST + 1,
            )
        ]
    if basename.endswith('.exe'):
        win_base, py_ver, platform = parse_bdist_wininst(basename)
        if win_base is not None:
            return interpret_distro_name(
                location, win_base, metadata, py_ver, BINARY_DIST, platform
            )
    # Try source distro extensions (.zip, .tgz, etc.)
    #
    for ext in EXTENSIONS:
        if basename.endswith(ext):
            basename = basename[: -len(ext)]
            return interpret_distro_name(location, basename, metadata)
    return []  # no extension matched


def distros_for_filename(filename, metadata=None):
    """Yield possible egg or source distribution objects based on a filename"""
    return distros_for_location(
        normalize_path(filename), os.path.basename(filename), metadata
    )


def interpret_distro_name(
    location, basename, metadata, py_version=None, precedence=SOURCE_DIST, platform=None
):
    """Generate the interpretation of a source distro name

    Note: if `location` is a filesystem filename, you should call
    ``pkg_resources.normalize_path()`` on it before passing it to this
    routine!
    """

    parts = basename.split('-')
    if not py_version and any(re.match(r'py\d\.\d$', p) for p in parts[2:]):
        # it is a bdist_dumb, not an sdist -- bail out
        return

    # find the pivot (p) that splits the name from the version.
    # infer the version as the first item that has a digit.
    for p in range(len(parts)):
        if parts[p][:1].isdigit():
            break
    else:
        p = len(parts)

    yield Distribution(
        location,
        metadata,
        '-'.join(parts[:p]),
        '-'.join(parts[p:]),
        py_version=py_version,
        precedence=precedence,
        platform=platform,
    )


def unique_values(func):
    """
    Wrap a function returning an iterable such that the resulting iterable
    only ever yields unique items.
    """

    @wraps(func)
    def wrapper(*args, **kwargs):
        return unique_everseen(func(*args, **kwargs))

    return wrapper


REL = re.compile(r"""<([^>]*\srel\s{0,10}=\s{0,10}['"]?([^'" >]+)[^>]*)>""", re.I)
"""
Regex for an HTML tag with 'rel="val"' attributes.
"""


@unique_values
def find_external_links(url, page):
    """Find rel="homepage" and rel="download" links in `page`, yielding URLs"""

    for match in REL.finditer(page):
        tag, rel = match.groups()
        rels = set(map(str.strip, rel.lower().split(',')))
        if 'homepage' in rels or 'download' in rels:
            for match in HREF.finditer(tag):
                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))

    for tag in ("Home Page", "Download URL"):
        pos = page.find(tag)
        if pos != -1:
            match = HREF.search(page, pos)
            if match:
                yield urllib.parse.urljoin(url, htmldecode(match.group(1)))


class ContentChecker:
    """
    A null content checker that defines the interface for checking content
    """

    def feed(self, block):
        """
        Feed a block of data to the hash.
        """
        return

    def is_valid(self):
        """
        Check the hash. Return False if validation fails.
        """
        return True

    def report(self, reporter, template):
        """
        Call reporter with information about the checker (hash name)
        substituted into the template.
        """
        return


class HashChecker(ContentChecker):
    pattern = re.compile(
        r'(?Psha1|sha224|sha384|sha256|sha512|md5)='
        r'(?P[a-f0-9]+)'
    )

    def __init__(self, hash_name, expected):
        self.hash_name = hash_name
        self.hash = hashlib.new(hash_name)
        self.expected = expected

    @classmethod
    def from_url(cls, url):
        "Construct a (possibly null) ContentChecker from a URL"
        fragment = urllib.parse.urlparse(url)[-1]
        if not fragment:
            return ContentChecker()
        match = cls.pattern.search(fragment)
        if not match:
            return ContentChecker()
        return cls(**match.groupdict())

    def feed(self, block):
        self.hash.update(block)

    def is_valid(self):
        return self.hash.hexdigest() == self.expected

    def report(self, reporter, template):
        msg = template % self.hash_name
        return reporter(msg)


class PackageIndex(Environment):
    """A distribution index that scans web pages for download URLs"""

    def __init__(
        self,
        index_url="https://pypi.org/simple/",
        hosts=('*',),
        ca_bundle=None,
        verify_ssl=True,
        *args,
        **kw,
    ):
        super().__init__(*args, **kw)
        self.index_url = index_url + "/"[: not index_url.endswith('/')]
        self.scanned_urls = {}
        self.fetched_urls = {}
        self.package_pages = {}
        self.allows = re.compile('|'.join(map(translate, hosts))).match
        self.to_scan = []
        self.opener = urllib.request.urlopen

    def add(self, dist):
        # ignore invalid versions
        try:
            parse_version(dist.version)
        except Exception:
            return
        return super().add(dist)

    # FIXME: 'PackageIndex.process_url' is too complex (14)
    def process_url(self, url, retrieve=False):  # noqa: C901
        """Evaluate a URL as a possible download, and maybe retrieve it"""
        if url in self.scanned_urls and not retrieve:
            return
        self.scanned_urls[url] = True
        if not URL_SCHEME(url):
            self.process_filename(url)
            return
        else:
            dists = list(distros_for_url(url))
            if dists:
                if not self.url_ok(url):
                    return
                self.debug("Found link: %s", url)

        if dists or not retrieve or url in self.fetched_urls:
            list(map(self.add, dists))
            return  # don't need the actual page

        if not self.url_ok(url):
            self.fetched_urls[url] = True
            return

        self.info("Reading %s", url)
        self.fetched_urls[url] = True  # prevent multiple fetch attempts
        tmpl = "Download error on %s: %%s -- Some packages may not be found!"
        f = self.open_url(url, tmpl % url)
        if f is None:
            return
        if isinstance(f, urllib.error.HTTPError) and f.code == 401:
            self.info("Authentication error: %s" % f.msg)
        self.fetched_urls[f.url] = True
        if 'html' not in f.headers.get('content-type', '').lower():
            f.close()  # not html, we can't process it
            return

        base = f.url  # handle redirects
        page = f.read()
        if not isinstance(page, str):
            # In Python 3 and got bytes but want str.
            if isinstance(f, urllib.error.HTTPError):
                # Errors have no charset, assume latin1:
                charset = 'latin-1'
            else:
                charset = f.headers.get_param('charset') or 'latin-1'
            page = page.decode(charset, "ignore")
        f.close()
        for match in HREF.finditer(page):
            link = urllib.parse.urljoin(base, htmldecode(match.group(1)))
            self.process_url(link)
        if url.startswith(self.index_url) and getattr(f, 'code', None) != 404:
            page = self.process_index(url, page)

    def process_filename(self, fn, nested=False):
        # process filenames or directories
        if not os.path.exists(fn):
            self.warn("Not found: %s", fn)
            return

        if os.path.isdir(fn) and not nested:
            path = os.path.realpath(fn)
            for item in os.listdir(path):
                self.process_filename(os.path.join(path, item), True)

        dists = distros_for_filename(fn)
        if dists:
            self.debug("Found: %s", fn)
            list(map(self.add, dists))

    def url_ok(self, url, fatal=False):
        s = URL_SCHEME(url)
        is_file = s and s.group(1).lower() == 'file'
        if is_file or self.allows(urllib.parse.urlparse(url)[1]):
            return True
        msg = (
            "\nNote: Bypassing %s (disallowed host; see "
            "https://setuptools.pypa.io/en/latest/deprecated/"
            "easy_install.html#restricting-downloads-with-allow-hosts for details).\n"
        )
        if fatal:
            raise DistutilsError(msg % url)
        else:
            self.warn(msg, url)

    def scan_egg_links(self, search_path):
        dirs = filter(os.path.isdir, search_path)
        egg_links = (
            (path, entry)
            for path in dirs
            for entry in os.listdir(path)
            if entry.endswith('.egg-link')
        )
        list(itertools.starmap(self.scan_egg_link, egg_links))

    def scan_egg_link(self, path, entry):
        with open(os.path.join(path, entry)) as raw_lines:
            # filter non-empty lines
            lines = list(filter(None, map(str.strip, raw_lines)))

        if len(lines) != 2:
            # format is not recognized; punt
            return

        egg_path, setup_path = lines

        for dist in find_distributions(os.path.join(path, egg_path)):
            dist.location = os.path.join(path, *lines)
            dist.precedence = SOURCE_DIST
            self.add(dist)

    def _scan(self, link):
        # Process a URL to see if it's for a package page
        NO_MATCH_SENTINEL = None, None
        if not link.startswith(self.index_url):
            return NO_MATCH_SENTINEL

        parts = list(map(urllib.parse.unquote, link[len(self.index_url) :].split('/')))
        if len(parts) != 2 or '#' in parts[1]:
            return NO_MATCH_SENTINEL

        # it's a package page, sanitize and index it
        pkg = safe_name(parts[0])
        ver = safe_version(parts[1])
        self.package_pages.setdefault(pkg.lower(), {})[link] = True
        return to_filename(pkg), to_filename(ver)

    def process_index(self, url, page):
        """Process the contents of a PyPI page"""

        # process an index page into the package-page index
        for match in HREF.finditer(page):
            try:
                self._scan(urllib.parse.urljoin(url, htmldecode(match.group(1))))
            except ValueError:
                pass

        pkg, ver = self._scan(url)  # ensure this page is in the page index
        if not pkg:
            return ""  # no sense double-scanning non-package pages

        # process individual package page
        for new_url in find_external_links(url, page):
            # Process the found URL
            base, frag = egg_info_for_url(new_url)
            if base.endswith('.py') and not frag:
                if ver:
                    new_url += '#egg=%s-%s' % (pkg, ver)
                else:
                    self.need_version_info(url)
            self.scan_url(new_url)

        return PYPI_MD5.sub(
            lambda m: '%s' % m.group(1, 3, 2), page
        )

    def need_version_info(self, url):
        self.scan_all(
            "Page at %s links to .py file(s) without version info; an index "
            "scan is required.",
            url,
        )

    def scan_all(self, msg=None, *args):
        if self.index_url not in self.fetched_urls:
            if msg:
                self.warn(msg, *args)
            self.info("Scanning index of all packages (this may take a while)")
        self.scan_url(self.index_url)

    def find_packages(self, requirement):
        self.scan_url(self.index_url + requirement.unsafe_name + '/')

        if not self.package_pages.get(requirement.key):
            # Fall back to safe version of the name
            self.scan_url(self.index_url + requirement.project_name + '/')

        if not self.package_pages.get(requirement.key):
            # We couldn't find the target package, so search the index page too
            self.not_found_in_index(requirement)

        for url in list(self.package_pages.get(requirement.key, ())):
            # scan each page that might be related to the desired package
            self.scan_url(url)

    def obtain(self, requirement, installer=None):
        self.prescan()
        self.find_packages(requirement)
        for dist in self[requirement.key]:
            if dist in requirement:
                return dist
            self.debug("%s does not match %s", requirement, dist)
        return super(PackageIndex, self).obtain(requirement, installer)

    def check_hash(self, checker, filename, tfp):
        """
        checker is a ContentChecker
        """
        checker.report(self.debug, "Validating %%s checksum for %s" % filename)
        if not checker.is_valid():
            tfp.close()
            os.unlink(filename)
            raise DistutilsError(
                "%s validation failed for %s; "
                "possible download problem?"
                % (checker.hash.name, os.path.basename(filename))
            )

    def add_find_links(self, urls):
        """Add `urls` to the list that will be prescanned for searches"""
        for url in urls:
            if (
                self.to_scan is None  # if we have already "gone online"
                or not URL_SCHEME(url)  # or it's a local file/directory
                or url.startswith('file:')
                or list(distros_for_url(url))  # or a direct package link
            ):
                # then go ahead and process it now
                self.scan_url(url)
            else:
                # otherwise, defer retrieval till later
                self.to_scan.append(url)

    def prescan(self):
        """Scan urls scheduled for prescanning (e.g. --find-links)"""
        if self.to_scan:
            list(map(self.scan_url, self.to_scan))
        self.to_scan = None  # from now on, go ahead and process immediately

    def not_found_in_index(self, requirement):
        if self[requirement.key]:  # we've seen at least one distro
            meth, msg = self.info, "Couldn't retrieve index page for %r"
        else:  # no distros seen for this name, might be misspelled
            meth, msg = (
                self.warn,
                "Couldn't find index page for %r (maybe misspelled?)",
            )
        meth(msg, requirement.unsafe_name)
        self.scan_all()

    def download(self, spec, tmpdir):
        """Locate and/or download `spec` to `tmpdir`, returning a local path

        `spec` may be a ``Requirement`` object, or a string containing a URL,
        an existing local filename, or a project/version requirement spec
        (i.e. the string form of a ``Requirement`` object).  If it is the URL
        of a .py file with an unambiguous ``#egg=name-version`` tag (i.e., one
        that escapes ``-`` as ``_`` throughout), a trivial ``setup.py`` is
        automatically created alongside the downloaded file.

        If `spec` is a ``Requirement`` object or a string containing a
        project/version requirement spec, this method returns the location of
        a matching distribution (possibly after downloading it to `tmpdir`).
        If `spec` is a locally existing file or directory name, it is simply
        returned unchanged.  If `spec` is a URL, it is downloaded to a subpath
        of `tmpdir`, and the local filename is returned.  Various errors may be
        raised if a problem occurs during downloading.
        """
        if not isinstance(spec, Requirement):
            scheme = URL_SCHEME(spec)
            if scheme:
                # It's a url, download it to tmpdir
                found = self._download_url(scheme.group(1), spec, tmpdir)
                base, fragment = egg_info_for_url(spec)
                if base.endswith('.py'):
                    found = self.gen_setup(found, fragment, tmpdir)
                return found
            elif os.path.exists(spec):
                # Existing file or directory, just return it
                return spec
            else:
                spec = parse_requirement_arg(spec)
        return getattr(self.fetch_distribution(spec, tmpdir), 'location', None)

    def fetch_distribution(  # noqa: C901  # is too complex (14)  # FIXME
        self,
        requirement,
        tmpdir,
        force_scan=False,
        source=False,
        develop_ok=False,
        local_index=None,
    ):
        """Obtain a distribution suitable for fulfilling `requirement`

        `requirement` must be a ``pkg_resources.Requirement`` instance.
        If necessary, or if the `force_scan` flag is set, the requirement is
        searched for in the (online) package index as well as the locally
        installed packages.  If a distribution matching `requirement` is found,
        the returned distribution's ``location`` is the value you would have
        gotten from calling the ``download()`` method with the matching
        distribution's URL or filename.  If no matching distribution is found,
        ``None`` is returned.

        If the `source` flag is set, only source distributions and source
        checkout links will be considered.  Unless the `develop_ok` flag is
        set, development and system eggs (i.e., those using the ``.egg-info``
        format) will be ignored.
        """
        # process a Requirement
        self.info("Searching for %s", requirement)
        skipped = {}
        dist = None

        def find(req, env=None):
            if env is None:
                env = self
            # Find a matching distribution; may be called more than once

            for dist in env[req.key]:
                if dist.precedence == DEVELOP_DIST and not develop_ok:
                    if dist not in skipped:
                        self.warn(
                            "Skipping development or system egg: %s",
                            dist,
                        )
                        skipped[dist] = 1
                    continue

                test = dist in req and (dist.precedence <= SOURCE_DIST or not source)
                if test:
                    loc = self.download(dist.location, tmpdir)
                    dist.download_location = loc
                    if os.path.exists(dist.download_location):
                        return dist

        if force_scan:
            self.prescan()
            self.find_packages(requirement)
            dist = find(requirement)

        if not dist and local_index is not None:
            dist = find(requirement, local_index)

        if dist is None:
            if self.to_scan is not None:
                self.prescan()
            dist = find(requirement)

        if dist is None and not force_scan:
            self.find_packages(requirement)
            dist = find(requirement)

        if dist is None:
            self.warn(
                "No local packages or working download links found for %s%s",
                (source and "a source distribution of " or ""),
                requirement,
            )
        else:
            self.info("Best match: %s", dist)
            return dist.clone(location=dist.download_location)

    def fetch(self, requirement, tmpdir, force_scan=False, source=False):
        """Obtain a file suitable for fulfilling `requirement`

        DEPRECATED; use the ``fetch_distribution()`` method now instead.  For
        backward compatibility, this routine is identical but returns the
        ``location`` of the downloaded distribution instead of a distribution
        object.
        """
        dist = self.fetch_distribution(requirement, tmpdir, force_scan, source)
        if dist is not None:
            return dist.location
        return None

    def gen_setup(self, filename, fragment, tmpdir):
        match = EGG_FRAGMENT.match(fragment)
        dists = (
            match
            and [
                d
                for d in interpret_distro_name(filename, match.group(1), None)
                if d.version
            ]
            or []
        )

        if len(dists) == 1:  # unambiguous ``#egg`` fragment
            basename = os.path.basename(filename)

            # Make sure the file has been downloaded to the temp dir.
            if os.path.dirname(filename) != tmpdir:
                dst = os.path.join(tmpdir, basename)
                if not (os.path.exists(dst) and os.path.samefile(filename, dst)):
                    shutil.copy2(filename, dst)
                    filename = dst

            with open(os.path.join(tmpdir, 'setup.py'), 'w') as file:
                file.write(
                    "from setuptools import setup\n"
                    "setup(name=%r, version=%r, py_modules=[%r])\n"
                    % (
                        dists[0].project_name,
                        dists[0].version,
                        os.path.splitext(basename)[0],
                    )
                )
            return filename

        elif match:
            raise DistutilsError(
                "Can't unambiguously interpret project/version identifier %r; "
                "any dashes in the name or version should be escaped using "
                "underscores. %r" % (fragment, dists)
            )
        else:
            raise DistutilsError(
                "Can't process plain .py files without an '#egg=name-version'"
                " suffix to enable automatic setup script generation."
            )

    dl_blocksize = 8192

    def _download_to(self, url, filename):
        self.info("Downloading %s", url)
        # Download the file
        fp = None
        try:
            checker = HashChecker.from_url(url)
            fp = self.open_url(url)
            if isinstance(fp, urllib.error.HTTPError):
                raise DistutilsError(
                    "Can't download %s: %s %s" % (url, fp.code, fp.msg)
                )
            headers = fp.info()
            blocknum = 0
            bs = self.dl_blocksize
            size = -1
            if "content-length" in headers:
                # Some servers return multiple Content-Length headers :(
                sizes = headers.get_all('Content-Length')
                size = max(map(int, sizes))
                self.reporthook(url, filename, blocknum, bs, size)
            with open(filename, 'wb') as tfp:
                while True:
                    block = fp.read(bs)
                    if block:
                        checker.feed(block)
                        tfp.write(block)
                        blocknum += 1
                        self.reporthook(url, filename, blocknum, bs, size)
                    else:
                        break
                self.check_hash(checker, filename, tfp)
            return headers
        finally:
            if fp:
                fp.close()

    def reporthook(self, url, filename, blocknum, blksize, size):
        pass  # no-op

    # FIXME:
    def open_url(self, url, warning=None):  # noqa: C901  # is too complex (12)
        if url.startswith('file:'):
            return local_open(url)
        try:
            return open_with_auth(url, self.opener)
        except (ValueError, http.client.InvalidURL) as v:
            msg = ' '.join([str(arg) for arg in v.args])
            if warning:
                self.warn(warning, msg)
            else:
                raise DistutilsError('%s %s' % (url, msg)) from v
        except urllib.error.HTTPError as v:
            return v
        except urllib.error.URLError as v:
            if warning:
                self.warn(warning, v.reason)
            else:
                raise DistutilsError(
                    "Download error for %s: %s" % (url, v.reason)
                ) from v
        except http.client.BadStatusLine as v:
            if warning:
                self.warn(warning, v.line)
            else:
                raise DistutilsError(
                    '%s returned a bad status line. The server might be '
                    'down, %s' % (url, v.line)
                ) from v
        except (http.client.HTTPException, socket.error) as v:
            if warning:
                self.warn(warning, v)
            else:
                raise DistutilsError("Download error for %s: %s" % (url, v)) from v

    def _download_url(self, scheme, url, tmpdir):
        # Determine download filename
        #
        name, fragment = egg_info_for_url(url)
        if name:
            while '..' in name:
                name = name.replace('..', '.').replace('\\', '_')
        else:
            name = "__downloaded__"  # default if URL has no path contents

        if name.endswith('.egg.zip'):
            name = name[:-4]  # strip the extra .zip before download

        filename = os.path.join(tmpdir, name)

        # Download the file
        #
        if scheme == 'svn' or scheme.startswith('svn+'):
            return self._download_svn(url, filename)
        elif scheme == 'git' or scheme.startswith('git+'):
            return self._download_git(url, filename)
        elif scheme.startswith('hg+'):
            return self._download_hg(url, filename)
        elif scheme == 'file':
            return urllib.request.url2pathname(urllib.parse.urlparse(url)[2])
        else:
            self.url_ok(url, True)  # raises error if not allowed
            return self._attempt_download(url, filename)

    def scan_url(self, url):
        self.process_url(url, True)

    def _attempt_download(self, url, filename):
        headers = self._download_to(url, filename)
        if 'html' in headers.get('content-type', '').lower():
            return self._invalid_download_html(url, headers, filename)
        else:
            return filename

    def _invalid_download_html(self, url, headers, filename):
        os.unlink(filename)
        raise DistutilsError(f"Unexpected HTML page found at {url}")

    def _download_svn(self, url, _filename):
        raise DistutilsError(f"Invalid config, SVN download is not supported: {url}")

    @staticmethod
    def _vcs_split_rev_from_url(url, pop_prefix=False):
        scheme, netloc, path, query, frag = urllib.parse.urlsplit(url)

        scheme = scheme.split('+', 1)[-1]

        # Some fragment identification fails
        path = path.split('#', 1)[0]

        rev = None
        if '@' in path:
            path, rev = path.rsplit('@', 1)

        # Also, discard fragment
        url = urllib.parse.urlunsplit((scheme, netloc, path, query, ''))

        return url, rev

    def _download_git(self, url, filename):
        filename = filename.split('#', 1)[0]
        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)

        self.info("Doing git clone from %s to %s", url, filename)
        os.system("git clone --quiet %s %s" % (url, filename))

        if rev is not None:
            self.info("Checking out %s", rev)
            os.system(
                "git -C %s checkout --quiet %s"
                % (
                    filename,
                    rev,
                )
            )

        return filename

    def _download_hg(self, url, filename):
        filename = filename.split('#', 1)[0]
        url, rev = self._vcs_split_rev_from_url(url, pop_prefix=True)

        self.info("Doing hg clone from %s to %s", url, filename)
        os.system("hg clone --quiet %s %s" % (url, filename))

        if rev is not None:
            self.info("Updating to %s", rev)
            os.system(
                "hg --cwd %s up -C -r %s -q"
                % (
                    filename,
                    rev,
                )
            )

        return filename

    def debug(self, msg, *args):
        log.debug(msg, *args)

    def info(self, msg, *args):
        log.info(msg, *args)

    def warn(self, msg, *args):
        log.warn(msg, *args)


# This pattern matches a character entity reference (a decimal numeric
# references, a hexadecimal numeric reference, or a named reference).
entity_sub = re.compile(r'&(#(\d+|x[\da-fA-F]+)|[\w.:-]+);?').sub


def decode_entity(match):
    what = match.group(0)
    return html.unescape(what)


def htmldecode(text):
    """
    Decode HTML entities in the given text.

    >>> htmldecode(
    ...     'https://../package_name-0.1.2.tar.gz'
    ...     '?tokena=A&tokenb=B">package_name-0.1.2.tar.gz')
    'https://../package_name-0.1.2.tar.gz?tokena=A&tokenb=B">package_name-0.1.2.tar.gz'
    """
    return entity_sub(decode_entity, text)


def socket_timeout(timeout=15):
    def _socket_timeout(func):
        def _socket_timeout(*args, **kwargs):
            old_timeout = socket.getdefaulttimeout()
            socket.setdefaulttimeout(timeout)
            try:
                return func(*args, **kwargs)
            finally:
                socket.setdefaulttimeout(old_timeout)

        return _socket_timeout

    return _socket_timeout


def _encode_auth(auth):
    """
    Encode auth from a URL suitable for an HTTP header.
    >>> str(_encode_auth('username%3Apassword'))
    'dXNlcm5hbWU6cGFzc3dvcmQ='

    Long auth strings should not cause a newline to be inserted.
    >>> long_auth = 'username:' + 'password'*10
    >>> chr(10) in str(_encode_auth(long_auth))
    False
    """
    auth_s = urllib.parse.unquote(auth)
    # convert to bytes
    auth_bytes = auth_s.encode()
    encoded_bytes = base64.b64encode(auth_bytes)
    # convert back to a string
    encoded = encoded_bytes.decode()
    # strip the trailing carriage return
    return encoded.replace('\n', '')


class Credential:
    """
    A username/password pair. Use like a namedtuple.
    """

    def __init__(self, username, password):
        self.username = username
        self.password = password

    def __iter__(self):
        yield self.username
        yield self.password

    def __str__(self):
        return '%(username)s:%(password)s' % vars(self)


class PyPIConfig(configparser.RawConfigParser):
    def __init__(self):
        """
        Load from ~/.pypirc
        """
        defaults = dict.fromkeys(['username', 'password', 'repository'], '')
        super().__init__(defaults)

        rc = os.path.join(os.path.expanduser('~'), '.pypirc')
        if os.path.exists(rc):
            self.read(rc)

    @property
    def creds_by_repository(self):
        sections_with_repositories = [
            section
            for section in self.sections()
            if self.get(section, 'repository').strip()
        ]

        return dict(map(self._get_repo_cred, sections_with_repositories))

    def _get_repo_cred(self, section):
        repo = self.get(section, 'repository').strip()
        return repo, Credential(
            self.get(section, 'username').strip(),
            self.get(section, 'password').strip(),
        )

    def find_credential(self, url):
        """
        If the URL indicated appears to be a repository defined in this
        config, return the credential for that repository.
        """
        for repository, cred in self.creds_by_repository.items():
            if url.startswith(repository):
                return cred


def open_with_auth(url, opener=urllib.request.urlopen):
    """Open a urllib2 request, handling HTTP authentication"""

    parsed = urllib.parse.urlparse(url)
    scheme, netloc, path, params, query, frag = parsed

    # Double scheme does not raise on macOS as revealed by a
    # failing test. We would expect "nonnumeric port". Refs #20.
    if netloc.endswith(':'):
        raise http.client.InvalidURL("nonnumeric port: ''")

    if scheme in ('http', 'https'):
        auth, address = _splituser(netloc)
    else:
        auth = None

    if not auth:
        cred = PyPIConfig().find_credential(url)
        if cred:
            auth = str(cred)
            info = cred.username, url
            log.info('Authenticating as %s for %s (from .pypirc)', *info)

    if auth:
        auth = "Basic " + _encode_auth(auth)
        parts = scheme, address, path, params, query, frag
        new_url = urllib.parse.urlunparse(parts)
        request = urllib.request.Request(new_url)
        request.add_header("Authorization", auth)
    else:
        request = urllib.request.Request(url)

    request.add_header('User-Agent', user_agent)
    fp = opener(request)

    if auth:
        # Put authentication info back into request URL if same host,
        # so that links found on the page will work
        s2, h2, path2, param2, query2, frag2 = urllib.parse.urlparse(fp.url)
        if s2 == scheme and h2 == address:
            parts = s2, netloc, path2, param2, query2, frag2
            fp.url = urllib.parse.urlunparse(parts)

    return fp


# copy of urllib.parse._splituser from Python 3.8
def _splituser(host):
    """splituser('user[:passwd]@host[:port]')
    --> 'user[:passwd]', 'host[:port]'."""
    user, delim, host = host.rpartition('@')
    return (user if delim else None), host


# adding a timeout to avoid freezing package_index
open_with_auth = socket_timeout(_SOCKET_TIMEOUT)(open_with_auth)


def fix_sf_url(url):
    return url  # backward compatibility


def local_open(url):
    """Read a local path, with special support for directories"""
    scheme, server, path, param, query, frag = urllib.parse.urlparse(url)
    filename = urllib.request.url2pathname(path)
    if os.path.isfile(filename):
        return urllib.request.urlopen(url)
    elif path.endswith('/') and os.path.isdir(filename):
        files = []
        for f in os.listdir(filename):
            filepath = os.path.join(filename, f)
            if f == 'index.html':
                with open(filepath, 'r') as fp:
                    body = fp.read()
                break
            elif os.path.isdir(filepath):
                f += '/'
            files.append('{name}'.format(name=f))
        else:
            tmpl = (
                "{url}" "{files}"
            )
            body = tmpl.format(url=url, files='\n'.join(files))
        status, message = 200, "OK"
    else:
        status, message, body = 404, "Path not found", "Not found"

    headers = {'content-type': 'text/html'}
    body_stream = io.StringIO(body)
    return urllib.error.HTTPError(url, status, message, headers, body_stream)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/py312compat.py0000644000175100001730000000051214467657412020325 0ustar00runnerdockerimport sys
import shutil


def shutil_rmtree(path, ignore_errors=False, onexc=None):
    if sys.version_info >= (3, 12):
        return shutil.rmtree(path, ignore_errors, onexc=onexc)

    def _handler(fn, path, excinfo):
        return onexc(fn, path, excinfo[1])

    return shutil.rmtree(path, ignore_errors, onerror=_handler)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/sandbox.py0000644000175100001730000003401514467657412017706 0ustar00runnerdockerimport os
import sys
import tempfile
import operator
import functools
import itertools
import re
import contextlib
import pickle
import textwrap
import builtins

import pkg_resources
from distutils.errors import DistutilsError
from pkg_resources import working_set

if sys.platform.startswith('java'):
    import org.python.modules.posix.PosixModule as _os
else:
    _os = sys.modules[os.name]
try:
    _file = file
except NameError:
    _file = None
_open = open


__all__ = [
    "AbstractSandbox",
    "DirectorySandbox",
    "SandboxViolation",
    "run_setup",
]


def _execfile(filename, globals, locals=None):
    """
    Python 3 implementation of execfile.
    """
    mode = 'rb'
    with open(filename, mode) as stream:
        script = stream.read()
    if locals is None:
        locals = globals
    code = compile(script, filename, 'exec')
    exec(code, globals, locals)


@contextlib.contextmanager
def save_argv(repl=None):
    saved = sys.argv[:]
    if repl is not None:
        sys.argv[:] = repl
    try:
        yield saved
    finally:
        sys.argv[:] = saved


@contextlib.contextmanager
def save_path():
    saved = sys.path[:]
    try:
        yield saved
    finally:
        sys.path[:] = saved


@contextlib.contextmanager
def override_temp(replacement):
    """
    Monkey-patch tempfile.tempdir with replacement, ensuring it exists
    """
    os.makedirs(replacement, exist_ok=True)

    saved = tempfile.tempdir

    tempfile.tempdir = replacement

    try:
        yield
    finally:
        tempfile.tempdir = saved


@contextlib.contextmanager
def pushd(target):
    saved = os.getcwd()
    os.chdir(target)
    try:
        yield saved
    finally:
        os.chdir(saved)


class UnpickleableException(Exception):
    """
    An exception representing another Exception that could not be pickled.
    """

    @staticmethod
    def dump(type, exc):
        """
        Always return a dumped (pickled) type and exc. If exc can't be pickled,
        wrap it in UnpickleableException first.
        """
        try:
            return pickle.dumps(type), pickle.dumps(exc)
        except Exception:
            # get UnpickleableException inside the sandbox
            from setuptools.sandbox import UnpickleableException as cls

            return cls.dump(cls, cls(repr(exc)))


class ExceptionSaver:
    """
    A Context Manager that will save an exception, serialized, and restore it
    later.
    """

    def __enter__(self):
        return self

    def __exit__(self, type, exc, tb):
        if not exc:
            return

        # dump the exception
        self._saved = UnpickleableException.dump(type, exc)
        self._tb = tb

        # suppress the exception
        return True

    def resume(self):
        "restore and re-raise any exception"

        if '_saved' not in vars(self):
            return

        type, exc = map(pickle.loads, self._saved)
        raise exc.with_traceback(self._tb)


@contextlib.contextmanager
def save_modules():
    """
    Context in which imported modules are saved.

    Translates exceptions internal to the context into the equivalent exception
    outside the context.
    """
    saved = sys.modules.copy()
    with ExceptionSaver() as saved_exc:
        yield saved

    sys.modules.update(saved)
    # remove any modules imported since
    del_modules = (
        mod_name
        for mod_name in sys.modules
        if mod_name not in saved
        # exclude any encodings modules. See #285
        and not mod_name.startswith('encodings.')
    )
    _clear_modules(del_modules)

    saved_exc.resume()


def _clear_modules(module_names):
    for mod_name in list(module_names):
        del sys.modules[mod_name]


@contextlib.contextmanager
def save_pkg_resources_state():
    saved = pkg_resources.__getstate__()
    try:
        yield saved
    finally:
        pkg_resources.__setstate__(saved)


@contextlib.contextmanager
def setup_context(setup_dir):
    temp_dir = os.path.join(setup_dir, 'temp')
    with save_pkg_resources_state():
        with save_modules():
            with save_path():
                hide_setuptools()
                with save_argv():
                    with override_temp(temp_dir):
                        with pushd(setup_dir):
                            # ensure setuptools commands are available
                            __import__('setuptools')
                            yield


_MODULES_TO_HIDE = {
    'setuptools',
    'distutils',
    'pkg_resources',
    'Cython',
    '_distutils_hack',
}


def _needs_hiding(mod_name):
    """
    >>> _needs_hiding('setuptools')
    True
    >>> _needs_hiding('pkg_resources')
    True
    >>> _needs_hiding('setuptools_plugin')
    False
    >>> _needs_hiding('setuptools.__init__')
    True
    >>> _needs_hiding('distutils')
    True
    >>> _needs_hiding('os')
    False
    >>> _needs_hiding('Cython')
    True
    """
    base_module = mod_name.split('.', 1)[0]
    return base_module in _MODULES_TO_HIDE


def hide_setuptools():
    """
    Remove references to setuptools' modules from sys.modules to allow the
    invocation to import the most appropriate setuptools. This technique is
    necessary to avoid issues such as #315 where setuptools upgrading itself
    would fail to find a function declared in the metadata.
    """
    _distutils_hack = sys.modules.get('_distutils_hack', None)
    if _distutils_hack is not None:
        _distutils_hack._remove_shim()

    modules = filter(_needs_hiding, sys.modules)
    _clear_modules(modules)


def run_setup(setup_script, args):
    """Run a distutils setup script, sandboxed in its directory"""
    setup_dir = os.path.abspath(os.path.dirname(setup_script))
    with setup_context(setup_dir):
        try:
            sys.argv[:] = [setup_script] + list(args)
            sys.path.insert(0, setup_dir)
            # reset to include setup dir, w/clean callback list
            working_set.__init__()
            working_set.callbacks.append(lambda dist: dist.activate())

            with DirectorySandbox(setup_dir):
                ns = dict(__file__=setup_script, __name__='__main__')
                _execfile(setup_script, ns)
        except SystemExit as v:
            if v.args and v.args[0]:
                raise
            # Normal exit, just return


class AbstractSandbox:
    """Wrap 'os' module and 'open()' builtin for virtualizing setup scripts"""

    _active = False

    def __init__(self):
        self._attrs = [
            name
            for name in dir(_os)
            if not name.startswith('_') and hasattr(self, name)
        ]

    def _copy(self, source):
        for name in self._attrs:
            setattr(os, name, getattr(source, name))

    def __enter__(self):
        self._copy(self)
        if _file:
            builtins.file = self._file
        builtins.open = self._open
        self._active = True

    def __exit__(self, exc_type, exc_value, traceback):
        self._active = False
        if _file:
            builtins.file = _file
        builtins.open = _open
        self._copy(_os)

    def run(self, func):
        """Run 'func' under os sandboxing"""
        with self:
            return func()

    def _mk_dual_path_wrapper(name):
        original = getattr(_os, name)

        def wrap(self, src, dst, *args, **kw):
            if self._active:
                src, dst = self._remap_pair(name, src, dst, *args, **kw)
            return original(src, dst, *args, **kw)

        return wrap

    for name in ["rename", "link", "symlink"]:
        if hasattr(_os, name):
            locals()[name] = _mk_dual_path_wrapper(name)

    def _mk_single_path_wrapper(name, original=None):
        original = original or getattr(_os, name)

        def wrap(self, path, *args, **kw):
            if self._active:
                path = self._remap_input(name, path, *args, **kw)
            return original(path, *args, **kw)

        return wrap

    if _file:
        _file = _mk_single_path_wrapper('file', _file)
    _open = _mk_single_path_wrapper('open', _open)
    for name in [
        "stat",
        "listdir",
        "chdir",
        "open",
        "chmod",
        "chown",
        "mkdir",
        "remove",
        "unlink",
        "rmdir",
        "utime",
        "lchown",
        "chroot",
        "lstat",
        "startfile",
        "mkfifo",
        "mknod",
        "pathconf",
        "access",
    ]:
        if hasattr(_os, name):
            locals()[name] = _mk_single_path_wrapper(name)

    def _mk_single_with_return(name):
        original = getattr(_os, name)

        def wrap(self, path, *args, **kw):
            if self._active:
                path = self._remap_input(name, path, *args, **kw)
                return self._remap_output(name, original(path, *args, **kw))
            return original(path, *args, **kw)

        return wrap

    for name in ['readlink', 'tempnam']:
        if hasattr(_os, name):
            locals()[name] = _mk_single_with_return(name)

    def _mk_query(name):
        original = getattr(_os, name)

        def wrap(self, *args, **kw):
            retval = original(*args, **kw)
            if self._active:
                return self._remap_output(name, retval)
            return retval

        return wrap

    for name in ['getcwd', 'tmpnam']:
        if hasattr(_os, name):
            locals()[name] = _mk_query(name)

    def _validate_path(self, path):
        """Called to remap or validate any path, whether input or output"""
        return path

    def _remap_input(self, operation, path, *args, **kw):
        """Called for path inputs"""
        return self._validate_path(path)

    def _remap_output(self, operation, path):
        """Called for path outputs"""
        return self._validate_path(path)

    def _remap_pair(self, operation, src, dst, *args, **kw):
        """Called for path pairs like rename, link, and symlink operations"""
        return (
            self._remap_input(operation + '-from', src, *args, **kw),
            self._remap_input(operation + '-to', dst, *args, **kw),
        )


if hasattr(os, 'devnull'):
    _EXCEPTIONS = [os.devnull]
else:
    _EXCEPTIONS = []


class DirectorySandbox(AbstractSandbox):
    """Restrict operations to a single subdirectory - pseudo-chroot"""

    write_ops = dict.fromkeys(
        [
            "open",
            "chmod",
            "chown",
            "mkdir",
            "remove",
            "unlink",
            "rmdir",
            "utime",
            "lchown",
            "chroot",
            "mkfifo",
            "mknod",
            "tempnam",
        ]
    )

    _exception_patterns = []
    "exempt writing to paths that match the pattern"

    def __init__(self, sandbox, exceptions=_EXCEPTIONS):
        self._sandbox = os.path.normcase(os.path.realpath(sandbox))
        self._prefix = os.path.join(self._sandbox, '')
        self._exceptions = [
            os.path.normcase(os.path.realpath(path)) for path in exceptions
        ]
        AbstractSandbox.__init__(self)

    def _violation(self, operation, *args, **kw):
        from setuptools.sandbox import SandboxViolation

        raise SandboxViolation(operation, args, kw)

    if _file:

        def _file(self, path, mode='r', *args, **kw):
            if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
                self._violation("file", path, mode, *args, **kw)
            return _file(path, mode, *args, **kw)

    def _open(self, path, mode='r', *args, **kw):
        if mode not in ('r', 'rt', 'rb', 'rU', 'U') and not self._ok(path):
            self._violation("open", path, mode, *args, **kw)
        return _open(path, mode, *args, **kw)

    def tmpnam(self):
        self._violation("tmpnam")

    def _ok(self, path):
        active = self._active
        try:
            self._active = False
            realpath = os.path.normcase(os.path.realpath(path))
            return (
                self._exempted(realpath)
                or realpath == self._sandbox
                or realpath.startswith(self._prefix)
            )
        finally:
            self._active = active

    def _exempted(self, filepath):
        start_matches = (
            filepath.startswith(exception) for exception in self._exceptions
        )
        pattern_matches = (
            re.match(pattern, filepath) for pattern in self._exception_patterns
        )
        candidates = itertools.chain(start_matches, pattern_matches)
        return any(candidates)

    def _remap_input(self, operation, path, *args, **kw):
        """Called for path inputs"""
        if operation in self.write_ops and not self._ok(path):
            self._violation(operation, os.path.realpath(path), *args, **kw)
        return path

    def _remap_pair(self, operation, src, dst, *args, **kw):
        """Called for path pairs like rename, link, and symlink operations"""
        if not self._ok(src) or not self._ok(dst):
            self._violation(operation, src, dst, *args, **kw)
        return (src, dst)

    def open(self, file, flags, mode=0o777, *args, **kw):
        """Called for low-level os.open()"""
        if flags & WRITE_FLAGS and not self._ok(file):
            self._violation("os.open", file, flags, mode, *args, **kw)
        return _os.open(file, flags, mode, *args, **kw)


WRITE_FLAGS = functools.reduce(
    operator.or_,
    [
        getattr(_os, a, 0)
        for a in "O_WRONLY O_RDWR O_APPEND O_CREAT O_TRUNC O_TEMPORARY".split()
    ],
)


class SandboxViolation(DistutilsError):
    """A setup script attempted to modify the filesystem outside the sandbox"""

    tmpl = textwrap.dedent(
        """
        SandboxViolation: {cmd}{args!r} {kwargs}

        The package setup script has attempted to modify files on your system
        that are not within the EasyInstall build area, and has been aborted.

        This package cannot be safely installed by EasyInstall, and may not
        support alternate installation locations even if you run its setup
        script by hand.  Please inform the package's author and the EasyInstall
        maintainers to find out if a fix or workaround is available.
        """
    ).lstrip()

    def __str__(self):
        cmd, args, kwargs = self.args
        return self.tmpl.format(**locals())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/script (dev).tmpl0000644000175100001730000000033214467657412020753 0ustar00runnerdocker# EASY-INSTALL-DEV-SCRIPT: %(spec)r,%(script_name)r
__requires__ = %(spec)r
__import__('pkg_resources').require(%(spec)r)
__file__ = %(dev_path)r
with open(__file__) as f:
    exec(compile(f.read(), __file__, 'exec'))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/script.tmpl0000644000175100001730000000021214467657412020070 0ustar00runnerdocker# EASY-INSTALL-SCRIPT: %(spec)r,%(script_name)r
__requires__ = %(spec)r
__import__('pkg_resources').run_script(%(spec)r, %(script_name)r)
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5515513
setuptools-68.1.2/setuptools/tests/0000755000175100001730000000000014467657444017042 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/__init__.py0000644000175100001730000000031214467657412021142 0ustar00runnerdockerimport locale

import pytest


__all__ = ['fail_on_ascii']


is_ascii = locale.getpreferredencoding() == 'ANSI_X3.4-1968'
fail_on_ascii = pytest.mark.xfail(is_ascii, reason="Test fails in this locale")
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5515513
setuptools-68.1.2/setuptools/tests/config/0000755000175100001730000000000014467657444020307 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/__init__.py0000644000175100001730000000000014467657412022401 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5515513
setuptools-68.1.2/setuptools/tests/config/downloads/0000755000175100001730000000000014467657444022301 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/downloads/__init__.py0000644000175100001730000000334214467657412024407 0ustar00runnerdockerimport re
import time
from pathlib import Path
from urllib.error import HTTPError
from urllib.request import urlopen

__all__ = ["DOWNLOAD_DIR", "retrieve_file", "output_file", "urls_from_file"]


NAME_REMOVE = ("http://", "https://", "github.com/", "/raw/")
DOWNLOAD_DIR = Path(__file__).parent


# ----------------------------------------------------------------------
# Please update ./preload.py accordingly when modifying this file
# ----------------------------------------------------------------------


def output_file(url: str, download_dir: Path = DOWNLOAD_DIR):
    file_name = url.strip()
    for part in NAME_REMOVE:
        file_name = file_name.replace(part, '').strip().strip('/:').strip()
    return Path(download_dir, re.sub(r"[^\-_\.\w\d]+", "_", file_name))


def retrieve_file(url: str, download_dir: Path = DOWNLOAD_DIR, wait: float = 5):
    path = output_file(url, download_dir)
    if path.exists():
        print(f"Skipping {url} (already exists: {path})")
    else:
        download_dir.mkdir(exist_ok=True, parents=True)
        print(f"Downloading {url} to {path}")
        try:
            download(url, path)
        except HTTPError:
            time.sleep(wait)  # wait a few seconds and try again.
            download(url, path)
    return path


def urls_from_file(list_file: Path):
    """``list_file`` should be a text file where each line corresponds to a URL to
    download.
    """
    print(f"file: {list_file}")
    content = list_file.read_text(encoding="utf-8")
    return [url for url in content.splitlines() if not url.startswith("#")]


def download(url: str, dest: Path):
    with urlopen(url) as f:
        data = f.read()

    with open(dest, "wb") as f:
        f.write(data)

    assert Path(dest).exists()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/downloads/preload.py0000644000175100001730000000070214467657412024273 0ustar00runnerdocker"""This file can be used to preload files needed for testing.

For example you can use::

    cd setuptools/tests/config
    python -m downloads.preload setupcfg_examples.txt

to make sure the `setup.cfg` examples are downloaded before starting the tests.
"""
import sys
from pathlib import Path

from . import retrieve_file, urls_from_file


if __name__ == "__main__":
    urls = urls_from_file(Path(sys.argv[1]))
    list(map(retrieve_file, urls))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/setupcfg_examples.txt0000644000175100001730000000371414467657412024566 0ustar00runnerdocker# ====================================================================
# Some popular packages that use setup.cfg (and others not so popular)
# Reference: https://hugovk.github.io/top-pypi-packages/
# ====================================================================
https://github.com/pypa/setuptools/raw/52c990172fec37766b3566679724aa8bf70ae06d/setup.cfg
https://github.com/pypa/wheel/raw/0acd203cd896afec7f715aa2ff5980a403459a3b/setup.cfg
https://github.com/python/importlib_metadata/raw/2f05392ca980952a6960d82b2f2d2ea10aa53239/setup.cfg
https://github.com/jaraco/skeleton/raw/d9008b5c510cd6969127a6a2ab6f832edddef296/setup.cfg
https://github.com/jaraco/zipp/raw/700d3a96390e970b6b962823bfea78b4f7e1c537/setup.cfg
https://github.com/pallets/jinja/raw/7d72eb7fefb7dce065193967f31f805180508448/setup.cfg
https://github.com/tkem/cachetools/raw/2fd87a94b8d3861d80e9e4236cd480bfdd21c90d/setup.cfg
https://github.com/aio-libs/aiohttp/raw/5e0e6b7080f2408d5f1dd544c0e1cf88378b7b10/setup.cfg
https://github.com/pallets/flask/raw/9486b6cf57bd6a8a261f67091aca8ca78eeec1e3/setup.cfg
https://github.com/pallets/click/raw/6411f425fae545f42795665af4162006b36c5e4a/setup.cfg
https://github.com/sqlalchemy/sqlalchemy/raw/533f5718904b620be8d63f2474229945d6f8ba5d/setup.cfg
https://github.com/pytest-dev/pluggy/raw/461ef63291d13589c4e21aa182cd1529257e9a0a/setup.cfg
https://github.com/pytest-dev/pytest/raw/c7be96dae487edbd2f55b561b31b68afac1dabe6/setup.cfg
https://github.com/tqdm/tqdm/raw/fc69d5dcf578f7c7986fa76841a6b793f813df35/setup.cfg
https://github.com/platformdirs/platformdirs/raw/7b7852128dd6f07511b618d6edea35046bd0c6ff/setup.cfg
https://github.com/pandas-dev/pandas/raw/bc17343f934a33dc231c8c74be95d8365537c376/setup.cfg
https://github.com/django/django/raw/4e249d11a6e56ca8feb4b055b681cec457ef3a3d/setup.cfg
https://github.com/pyscaffold/pyscaffold/raw/de7aa5dc059fbd04307419c667cc4961bc9df4b8/setup.cfg
https://github.com/pypa/virtualenv/raw/f92eda6e3da26a4d28c2663ffb85c4960bdb990c/setup.cfg
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/test_apply_pyprojecttoml.py0000644000175100001730000004140614467657412026040 0ustar00runnerdocker"""Make sure that applying the configuration from pyproject.toml is equivalent to
applying a similar configuration from setup.cfg

To run these tests offline, please have a look on ``./downloads/preload.py``
"""
import io
import re
import tarfile
from inspect import cleandoc
from pathlib import Path
from unittest.mock import Mock
from zipfile import ZipFile

import pytest
from ini2toml.api import Translator

import setuptools  # noqa ensure monkey patch to metadata
from setuptools.dist import Distribution
from setuptools.config import setupcfg, pyprojecttoml
from setuptools.config import expand
from setuptools.config._apply_pyprojecttoml import _WouldIgnoreField, _some_attrgetter
from setuptools.command.egg_info import write_requirements
from setuptools.warnings import SetuptoolsDeprecationWarning

from .downloads import retrieve_file, urls_from_file


HERE = Path(__file__).parent
EXAMPLES_FILE = "setupcfg_examples.txt"


def makedist(path, **attrs):
    return Distribution({"src_root": path, **attrs})


@pytest.mark.parametrize("url", urls_from_file(HERE / EXAMPLES_FILE))
@pytest.mark.filterwarnings("ignore")
@pytest.mark.uses_network
def test_apply_pyproject_equivalent_to_setupcfg(url, monkeypatch, tmp_path):
    monkeypatch.setattr(expand, "read_attr", Mock(return_value="0.0.1"))
    setupcfg_example = retrieve_file(url)
    pyproject_example = Path(tmp_path, "pyproject.toml")
    toml_config = Translator().translate(setupcfg_example.read_text(), "setup.cfg")
    pyproject_example.write_text(toml_config)

    dist_toml = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject_example)
    dist_cfg = setupcfg.apply_configuration(makedist(tmp_path), setupcfg_example)

    pkg_info_toml = core_metadata(dist_toml)
    pkg_info_cfg = core_metadata(dist_cfg)
    assert pkg_info_toml == pkg_info_cfg

    if any(getattr(d, "license_files", None) for d in (dist_toml, dist_cfg)):
        assert set(dist_toml.license_files) == set(dist_cfg.license_files)

    if any(getattr(d, "entry_points", None) for d in (dist_toml, dist_cfg)):
        print(dist_cfg.entry_points)
        ep_toml = {
            (k, *sorted(i.replace(" ", "") for i in v))
            for k, v in dist_toml.entry_points.items()
        }
        ep_cfg = {
            (k, *sorted(i.replace(" ", "") for i in v))
            for k, v in dist_cfg.entry_points.items()
        }
        assert ep_toml == ep_cfg

    if any(getattr(d, "package_data", None) for d in (dist_toml, dist_cfg)):
        pkg_data_toml = {(k, *sorted(v)) for k, v in dist_toml.package_data.items()}
        pkg_data_cfg = {(k, *sorted(v)) for k, v in dist_cfg.package_data.items()}
        assert pkg_data_toml == pkg_data_cfg

    if any(getattr(d, "data_files", None) for d in (dist_toml, dist_cfg)):
        data_files_toml = {(k, *sorted(v)) for k, v in dist_toml.data_files}
        data_files_cfg = {(k, *sorted(v)) for k, v in dist_cfg.data_files}
        assert data_files_toml == data_files_cfg

    assert set(dist_toml.install_requires) == set(dist_cfg.install_requires)
    if any(getattr(d, "extras_require", None) for d in (dist_toml, dist_cfg)):
        if (
            "testing" in dist_toml.extras_require
            and "testing" not in dist_cfg.extras_require
        ):
            # ini2toml can automatically convert `tests_require` to `testing` extra
            dist_toml.extras_require.pop("testing")
        extra_req_toml = {(k, *sorted(v)) for k, v in dist_toml.extras_require.items()}
        extra_req_cfg = {(k, *sorted(v)) for k, v in dist_cfg.extras_require.items()}
        assert extra_req_toml == extra_req_cfg


PEP621_EXAMPLE = """\
[project]
name = "spam"
version = "2020.0.0"
description = "Lovely Spam! Wonderful Spam!"
readme = "README.rst"
requires-python = ">=3.8"
license = {file = "LICENSE.txt"}
keywords = ["egg", "bacon", "sausage", "tomatoes", "Lobster Thermidor"]
authors = [
  {email = "hi@pradyunsg.me"},
  {name = "Tzu-Ping Chung"}
]
maintainers = [
  {name = "Brett Cannon", email = "brett@python.org"},
  {name = "John X. Ãørçeč", email = "john@utf8.org"},
  {name = "Γαμα קּ 東", email = "gama@utf8.org"},
]
classifiers = [
  "Development Status :: 4 - Beta",
  "Programming Language :: Python"
]

dependencies = [
  "httpx",
  "gidgethub[httpx]>4.0.0",
  "django>2.1; os_name != 'nt'",
  "django>2.0; os_name == 'nt'"
]

[project.optional-dependencies]
test = [
  "pytest < 5.0.0",
  "pytest-cov[all]"
]

[project.urls]
homepage = "http://example.com"
documentation = "http://readthedocs.org"
repository = "http://github.com"
changelog = "http://github.com/me/spam/blob/master/CHANGELOG.md"

[project.scripts]
spam-cli = "spam:main_cli"

[project.gui-scripts]
spam-gui = "spam:main_gui"

[project.entry-points."spam.magical"]
tomatoes = "spam:main_tomatoes"
"""

PEP621_INTERNATIONAL_EMAIL_EXAMPLE = """\
[project]
name = "spam"
version = "2020.0.0"
authors = [
  {email = "hi@pradyunsg.me"},
  {name = "Tzu-Ping Chung"}
]
maintainers = [
  {name = "Степан Бандера", email = "криївка@оун-упа.укр"},
]
"""

PEP621_EXAMPLE_SCRIPT = """
def main_cli(): pass
def main_gui(): pass
def main_tomatoes(): pass
"""


def _pep621_example_project(
    tmp_path,
    readme="README.rst",
    pyproject_text=PEP621_EXAMPLE,
):
    pyproject = tmp_path / "pyproject.toml"
    text = pyproject_text
    replacements = {'readme = "README.rst"': f'readme = "{readme}"'}
    for orig, subst in replacements.items():
        text = text.replace(orig, subst)
    pyproject.write_text(text, encoding="utf-8")

    (tmp_path / readme).write_text("hello world")
    (tmp_path / "LICENSE.txt").write_text("--- LICENSE stub ---")
    (tmp_path / "spam.py").write_text(PEP621_EXAMPLE_SCRIPT)
    return pyproject


def test_pep621_example(tmp_path):
    """Make sure the example in PEP 621 works"""
    pyproject = _pep621_example_project(tmp_path)
    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
    assert dist.metadata.license == "--- LICENSE stub ---"
    assert set(dist.metadata.license_files) == {"LICENSE.txt"}


@pytest.mark.parametrize(
    "readme, ctype",
    [
        ("Readme.txt", "text/plain"),
        ("readme.md", "text/markdown"),
        ("text.rst", "text/x-rst"),
    ],
)
def test_readme_content_type(tmp_path, readme, ctype):
    pyproject = _pep621_example_project(tmp_path, readme)
    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
    assert dist.metadata.long_description_content_type == ctype


def test_undefined_content_type(tmp_path):
    pyproject = _pep621_example_project(tmp_path, "README.tex")
    with pytest.raises(ValueError, match="Undefined content type for README.tex"):
        pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)


def test_no_explicit_content_type_for_missing_extension(tmp_path):
    pyproject = _pep621_example_project(tmp_path, "README")
    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
    assert dist.metadata.long_description_content_type is None


@pytest.mark.parametrize(
    ('pyproject_text', 'expected_maintainers_meta_value'),
    (
        pytest.param(
            PEP621_EXAMPLE,
            (
                'Brett Cannon , "John X. Ãørçeč" , '
                'Γαμα קּ 東 '
            ),
            id='non-international-emails',
        ),
        pytest.param(
            PEP621_INTERNATIONAL_EMAIL_EXAMPLE,
            'Степан Бандера <криївка@оун-упа.укр>',
            marks=pytest.mark.xfail(
                reason="CPython's `email.headerregistry.Address` only supports "
                'RFC 5322, as of Nov 10, 2022 and latest Python 3.11.0',
                strict=True,
            ),
            id='international-email',
        ),
    ),
)
def test_utf8_maintainer_in_metadata(  # issue-3663
    expected_maintainers_meta_value,
    pyproject_text,
    tmp_path,
):
    pyproject = _pep621_example_project(
        tmp_path,
        "README",
        pyproject_text=pyproject_text,
    )
    dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
    assert dist.metadata.maintainer_email == expected_maintainers_meta_value
    pkg_file = tmp_path / "PKG-FILE"
    with open(pkg_file, "w", encoding="utf-8") as fh:
        dist.metadata.write_pkg_file(fh)
    content = pkg_file.read_text(encoding="utf-8")
    assert f"Maintainer-email: {expected_maintainers_meta_value}" in content


class TestLicenseFiles:
    # TODO: After PEP 639 is accepted, we have to move the license-files
    #       to the `project` table instead of `tool.setuptools`

    def base_pyproject(self, tmp_path, additional_text):
        pyproject = _pep621_example_project(tmp_path, "README")
        text = pyproject.read_text(encoding="utf-8")

        # Sanity-check
        assert 'license = {file = "LICENSE.txt"}' in text
        assert "[tool.setuptools]" not in text

        text = f"{text}\n{additional_text}\n"
        pyproject.write_text(text, encoding="utf-8")
        return pyproject

    def test_both_license_and_license_files_defined(self, tmp_path):
        setuptools_config = '[tool.setuptools]\nlicense-files = ["_FILE*"]'
        pyproject = self.base_pyproject(tmp_path, setuptools_config)

        (tmp_path / "_FILE.txt").touch()
        (tmp_path / "_FILE.rst").touch()

        # Would normally match the `license_files` patterns, but we want to exclude it
        # by being explicit. On the other hand, contents should be added to `license`
        license = tmp_path / "LICENSE.txt"
        license.write_text("LicenseRef-Proprietary\n", encoding="utf-8")

        dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
        assert set(dist.metadata.license_files) == {"_FILE.rst", "_FILE.txt"}
        assert dist.metadata.license == "LicenseRef-Proprietary\n"

    def test_default_patterns(self, tmp_path):
        setuptools_config = '[tool.setuptools]\nzip-safe = false'
        # ^ used just to trigger section validation
        pyproject = self.base_pyproject(tmp_path, setuptools_config)

        license_files = "LICENCE-a.html COPYING-abc.txt AUTHORS-xyz NOTICE,def".split()

        for fname in license_files:
            (tmp_path / fname).write_text(f"{fname}\n", encoding="utf-8")

        dist = pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)
        assert (tmp_path / "LICENSE.txt").exists()  # from base example
        assert set(dist.metadata.license_files) == {*license_files, "LICENSE.txt"}


class TestDeprecatedFields:
    def test_namespace_packages(self, tmp_path):
        pyproject = tmp_path / "pyproject.toml"
        config = """
        [project]
        name = "myproj"
        version = "42"
        [tool.setuptools]
        namespace-packages = ["myproj.pkg"]
        """
        pyproject.write_text(cleandoc(config), encoding="utf-8")
        with pytest.warns(SetuptoolsDeprecationWarning, match="namespace_packages"):
            pyprojecttoml.apply_configuration(makedist(tmp_path), pyproject)


class TestPresetField:
    def pyproject(self, tmp_path, dynamic, extra_content=""):
        content = f"[project]\nname = 'proj'\ndynamic = {dynamic!r}\n"
        if "version" not in dynamic:
            content += "version = '42'\n"
        file = tmp_path / "pyproject.toml"
        file.write_text(content + extra_content, encoding="utf-8")
        return file

    @pytest.mark.parametrize(
        "attr, field, value",
        [
            ("install_requires", "dependencies", ["six"]),
            ("classifiers", "classifiers", ["Private :: Classifier"]),
            ("entry_points", "scripts", {"console_scripts": ["foobar=foobar:main"]}),
            ("entry_points", "gui-scripts", {"gui_scripts": ["bazquux=bazquux:main"]}),
        ],
    )
    def test_not_listed_in_dynamic(self, tmp_path, attr, field, value):
        """For the time being we just warn if the user pre-set values (e.g. via
        ``setup.py``) but do not include them in ``dynamic``.
        """
        pyproject = self.pyproject(tmp_path, [])
        dist = makedist(tmp_path, **{attr: value})
        msg = re.compile(f"defined outside of `pyproject.toml`:.*{field}", re.S)
        with pytest.warns(_WouldIgnoreField, match=msg):
            dist = pyprojecttoml.apply_configuration(dist, pyproject)

        # TODO: Once support for pyproject.toml config stabilizes attr should be None
        dist_value = _some_attrgetter(f"metadata.{attr}", attr)(dist)
        assert dist_value == value

    @pytest.mark.parametrize(
        "attr, field, value",
        [
            ("install_requires", "dependencies", []),
            ("extras_require", "optional-dependencies", {}),
            ("install_requires", "dependencies", ["six"]),
            ("classifiers", "classifiers", ["Private :: Classifier"]),
        ],
    )
    def test_listed_in_dynamic(self, tmp_path, attr, field, value):
        pyproject = self.pyproject(tmp_path, [field])
        dist = makedist(tmp_path, **{attr: value})
        dist = pyprojecttoml.apply_configuration(dist, pyproject)
        dist_value = _some_attrgetter(f"metadata.{attr}", attr)(dist)
        assert dist_value == value

    def test_warning_overwritten_dependencies(self, tmp_path):
        src = "[project]\nname='pkg'\nversion='0.1'\ndependencies=['click']\n"
        pyproject = tmp_path / "pyproject.toml"
        pyproject.write_text(src, encoding="utf-8")
        dist = makedist(tmp_path, install_requires=["wheel"])
        with pytest.warns(match="`install_requires` overwritten"):
            dist = pyprojecttoml.apply_configuration(dist, pyproject)
        assert "wheel" not in dist.install_requires

    def test_optional_dependencies_dont_remove_env_markers(self, tmp_path):
        """
        Internally setuptools converts dependencies with markers to "extras".
        If ``install_requires`` is given by ``setup.py``, we have to ensure that
        applying ``optional-dependencies`` does not overwrite the mandatory
        dependencies with markers (see #3204).
        """
        # If setuptools replace its internal mechanism that uses `requires.txt`
        # this test has to be rewritten to adapt accordingly
        extra = "\n[project.optional-dependencies]\nfoo = ['bar>1']\n"
        pyproject = self.pyproject(tmp_path, ["dependencies"], extra)
        install_req = ['importlib-resources (>=3.0.0) ; python_version < "3.7"']
        dist = makedist(tmp_path, install_requires=install_req)
        dist = pyprojecttoml.apply_configuration(dist, pyproject)
        assert "foo" in dist.extras_require
        assert ':python_version < "3.7"' in dist.extras_require
        egg_info = dist.get_command_obj("egg_info")
        write_requirements(egg_info, tmp_path, tmp_path / "requires.txt")
        reqs = (tmp_path / "requires.txt").read_text(encoding="utf-8")
        assert "importlib-resources" in reqs
        assert "bar" in reqs

    @pytest.mark.parametrize(
        "field,group", [("scripts", "console_scripts"), ("gui-scripts", "gui_scripts")]
    )
    @pytest.mark.filterwarnings("error")
    def test_scripts_dont_require_dynamic_entry_points(self, tmp_path, field, group):
        # Issue 3862
        pyproject = self.pyproject(tmp_path, [field])
        dist = makedist(tmp_path, entry_points={group: ["foobar=foobar:main"]})
        dist = pyprojecttoml.apply_configuration(dist, pyproject)
        assert group in dist.entry_points


class TestMeta:
    def test_example_file_in_sdist(self, setuptools_sdist):
        """Meta test to ensure tests can run from sdist"""
        with tarfile.open(setuptools_sdist) as tar:
            assert any(name.endswith(EXAMPLES_FILE) for name in tar.getnames())

    def test_example_file_not_in_wheel(self, setuptools_wheel):
        """Meta test to ensure auxiliary test files are not in wheel"""
        with ZipFile(setuptools_wheel) as zipfile:
            assert not any(name.endswith(EXAMPLES_FILE) for name in zipfile.namelist())


# --- Auxiliary Functions ---


def core_metadata(dist) -> str:
    with io.StringIO() as buffer:
        dist.metadata.write_pkg_file(buffer)
        pkg_file_txt = buffer.getvalue()

    skip_prefixes = ()
    skip_lines = set()
    # ---- DIFF NORMALISATION ----
    # PEP 621 is very particular about author/maintainer metadata conversion, so skip
    skip_prefixes += ("Author:", "Author-email:", "Maintainer:", "Maintainer-email:")
    # May be redundant with Home-page
    skip_prefixes += ("Project-URL: Homepage,", "Home-page:")
    # May be missing in original (relying on default) but backfilled in the TOML
    skip_prefixes += ("Description-Content-Type:",)
    # ini2toml can automatically convert `tests_require` to `testing` extra
    skip_lines.add("Provides-Extra: testing")
    # Remove empty lines
    skip_lines.add("")

    result = []
    for line in pkg_file_txt.splitlines():
        if line.startswith(skip_prefixes) or line in skip_lines:
            continue
        result.append(line + "\n")

    return "".join(result)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/test_expand.py0000644000175100001730000001751014467657412023176 0ustar00runnerdockerimport os
from pathlib import Path

import pytest

from distutils.errors import DistutilsOptionError
from setuptools.config import expand
from setuptools.discovery import find_package_path


def write_files(files, root_dir):
    for file, content in files.items():
        path = root_dir / file
        path.parent.mkdir(exist_ok=True, parents=True)
        path.write_text(content)


def test_glob_relative(tmp_path, monkeypatch):
    files = {
        "dir1/dir2/dir3/file1.txt",
        "dir1/dir2/file2.txt",
        "dir1/file3.txt",
        "a.ini",
        "b.ini",
        "dir1/c.ini",
        "dir1/dir2/a.ini",
    }

    write_files({k: "" for k in files}, tmp_path)
    patterns = ["**/*.txt", "[ab].*", "**/[ac].ini"]
    monkeypatch.chdir(tmp_path)
    assert set(expand.glob_relative(patterns)) == files
    # Make sure the same APIs work outside cwd
    assert set(expand.glob_relative(patterns, tmp_path)) == files


def test_read_files(tmp_path, monkeypatch):
    dir_ = tmp_path / "dir_"
    (tmp_path / "_dir").mkdir(exist_ok=True)
    (tmp_path / "a.txt").touch()
    files = {"a.txt": "a", "dir1/b.txt": "b", "dir1/dir2/c.txt": "c"}
    write_files(files, dir_)

    secrets = Path(str(dir_) + "secrets")
    secrets.mkdir(exist_ok=True)
    write_files({"secrets.txt": "secret keys"}, secrets)

    with monkeypatch.context() as m:
        m.chdir(dir_)
        assert expand.read_files(list(files)) == "a\nb\nc"

        cannot_access_msg = r"Cannot access '.*\.\..a\.txt'"
        with pytest.raises(DistutilsOptionError, match=cannot_access_msg):
            expand.read_files(["../a.txt"])

        cannot_access_secrets_msg = r"Cannot access '.*secrets\.txt'"
        with pytest.raises(DistutilsOptionError, match=cannot_access_secrets_msg):
            expand.read_files(["../dir_secrets/secrets.txt"])

    # Make sure the same APIs work outside cwd
    assert expand.read_files(list(files), dir_) == "a\nb\nc"
    with pytest.raises(DistutilsOptionError, match=cannot_access_msg):
        expand.read_files(["../a.txt"], dir_)


class TestReadAttr:
    @pytest.mark.parametrize(
        "example",
        [
            # No cookie means UTF-8:
            b"__version__ = '\xc3\xa9'\nraise SystemExit(1)\n",
            # If a cookie is present, honor it:
            b"# -*- coding: utf-8 -*-\n__version__ = '\xc3\xa9'\nraise SystemExit(1)\n",
            b"# -*- coding: latin1 -*-\n__version__ = '\xe9'\nraise SystemExit(1)\n",
        ],
    )
    def test_read_attr_encoding_cookie(self, example, tmp_path):
        (tmp_path / "mod.py").write_bytes(example)
        assert expand.read_attr('mod.__version__', root_dir=tmp_path) == 'é'

    def test_read_attr(self, tmp_path, monkeypatch):
        files = {
            "pkg/__init__.py": "",
            "pkg/sub/__init__.py": "VERSION = '0.1.1'",
            "pkg/sub/mod.py": (
                "VALUES = {'a': 0, 'b': {42}, 'c': (0, 1, 1)}\n" "raise SystemExit(1)"
            ),
        }
        write_files(files, tmp_path)

        with monkeypatch.context() as m:
            m.chdir(tmp_path)
            # Make sure it can read the attr statically without evaluating the module
            assert expand.read_attr('pkg.sub.VERSION') == '0.1.1'
            values = expand.read_attr('lib.mod.VALUES', {'lib': 'pkg/sub'})

        assert values['a'] == 0
        assert values['b'] == {42}

        # Make sure the same APIs work outside cwd
        assert expand.read_attr('pkg.sub.VERSION', root_dir=tmp_path) == '0.1.1'
        values = expand.read_attr('lib.mod.VALUES', {'lib': 'pkg/sub'}, tmp_path)
        assert values['c'] == (0, 1, 1)

    @pytest.mark.parametrize(
        "example",
        [
            "VERSION: str\nVERSION = '0.1.1'\nraise SystemExit(1)\n",
            "VERSION: str = '0.1.1'\nraise SystemExit(1)\n",
        ],
    )
    def test_read_annotated_attr(self, tmp_path, example):
        files = {
            "pkg/__init__.py": "",
            "pkg/sub/__init__.py": example,
        }
        write_files(files, tmp_path)
        # Make sure this attribute can be read statically
        assert expand.read_attr('pkg.sub.VERSION', root_dir=tmp_path) == '0.1.1'

    def test_import_order(self, tmp_path):
        """
        Sometimes the import machinery will import the parent package of a nested
        module, which triggers side-effects and might create problems (see issue #3176)

        ``read_attr`` should bypass these limitations by resolving modules statically
        (via ast.literal_eval).
        """
        files = {
            "src/pkg/__init__.py": "from .main import func\nfrom .about import version",
            "src/pkg/main.py": "import super_complicated_dep\ndef func(): return 42",
            "src/pkg/about.py": "version = '42'",
        }
        write_files(files, tmp_path)
        attr_desc = "pkg.about.version"
        package_dir = {"": "src"}
        # `import super_complicated_dep` should not run, otherwise the build fails
        assert expand.read_attr(attr_desc, package_dir, tmp_path) == "42"


@pytest.mark.parametrize(
    'package_dir, file, module, return_value',
    [
        ({"": "src"}, "src/pkg/main.py", "pkg.main", 42),
        ({"pkg": "lib"}, "lib/main.py", "pkg.main", 13),
        ({}, "single_module.py", "single_module", 70),
        ({}, "flat_layout/pkg.py", "flat_layout.pkg", 836),
    ],
)
def test_resolve_class(tmp_path, package_dir, file, module, return_value):
    files = {file: f"class Custom:\n    def testing(self): return {return_value}"}
    write_files(files, tmp_path)
    cls = expand.resolve_class(f"{module}.Custom", package_dir, tmp_path)
    assert cls().testing() == return_value


@pytest.mark.parametrize(
    'args, pkgs',
    [
        ({"where": ["."], "namespaces": False}, {"pkg", "other"}),
        ({"where": [".", "dir1"], "namespaces": False}, {"pkg", "other", "dir2"}),
        ({"namespaces": True}, {"pkg", "other", "dir1", "dir1.dir2"}),
        ({}, {"pkg", "other", "dir1", "dir1.dir2"}),  # default value for `namespaces`
    ],
)
def test_find_packages(tmp_path, args, pkgs):
    files = {
        "pkg/__init__.py",
        "other/__init__.py",
        "dir1/dir2/__init__.py",
    }
    write_files({k: "" for k in files}, tmp_path)

    package_dir = {}
    kwargs = {"root_dir": tmp_path, "fill_package_dir": package_dir, **args}
    where = kwargs.get("where", ["."])
    assert set(expand.find_packages(**kwargs)) == pkgs
    for pkg in pkgs:
        pkg_path = find_package_path(pkg, package_dir, tmp_path)
        assert os.path.exists(pkg_path)

    # Make sure the same APIs work outside cwd
    where = [
        str((tmp_path / p).resolve()).replace(os.sep, "/")  # ensure posix-style paths
        for p in args.pop("where", ["."])
    ]

    assert set(expand.find_packages(where=where, **args)) == pkgs


@pytest.mark.parametrize(
    "files, where, expected_package_dir",
    [
        (["pkg1/__init__.py", "pkg1/other.py"], ["."], {}),
        (["pkg1/__init__.py", "pkg2/__init__.py"], ["."], {}),
        (["src/pkg1/__init__.py", "src/pkg1/other.py"], ["src"], {"": "src"}),
        (["src/pkg1/__init__.py", "src/pkg2/__init__.py"], ["src"], {"": "src"}),
        (
            ["src1/pkg1/__init__.py", "src2/pkg2/__init__.py"],
            ["src1", "src2"],
            {"pkg1": "src1/pkg1", "pkg2": "src2/pkg2"},
        ),
        (
            ["src/pkg1/__init__.py", "pkg2/__init__.py"],
            ["src", "."],
            {"pkg1": "src/pkg1"},
        ),
    ],
)
def test_fill_package_dir(tmp_path, files, where, expected_package_dir):
    write_files({k: "" for k in files}, tmp_path)
    pkg_dir = {}
    kwargs = {"root_dir": tmp_path, "fill_package_dir": pkg_dir, "namespaces": False}
    pkgs = expand.find_packages(where=where, **kwargs)
    assert set(pkg_dir.items()) == set(expected_package_dir.items())
    for pkg in pkgs:
        pkg_path = find_package_path(pkg, pkg_dir, tmp_path)
        assert os.path.exists(pkg_path)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/test_pyprojecttoml.py0000644000175100001730000002720214467657412024631 0ustar00runnerdockerimport re
from configparser import ConfigParser
from inspect import cleandoc

import pytest
import tomli_w
from path import Path as _Path

from setuptools.config._apply_pyprojecttoml import _WouldIgnoreField
from setuptools.config.pyprojecttoml import (
    read_configuration,
    expand_configuration,
    apply_configuration,
    validate,
)
from setuptools.dist import Distribution
from setuptools.errors import OptionError


import setuptools  # noqa -- force distutils.core to be patched
import distutils.core

EXAMPLE = """
[project]
name = "myproj"
keywords = ["some", "key", "words"]
dynamic = ["version", "readme"]
requires-python = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
dependencies = [
    'importlib-metadata>=0.12;python_version<"3.8"',
    'importlib-resources>=1.0;python_version<"3.7"',
    'pathlib2>=2.3.3,<3;python_version < "3.4" and sys.platform != "win32"',
]

[project.optional-dependencies]
docs = [
    "sphinx>=3",
    "sphinx-argparse>=0.2.5",
    "sphinx-rtd-theme>=0.4.3",
]
testing = [
    "pytest>=1",
    "coverage>=3,<5",
]

[project.scripts]
exec = "pkg.__main__:exec"

[build-system]
requires = ["setuptools", "wheel"]
build-backend = "setuptools.build_meta"

[tool.setuptools]
package-dir = {"" = "src"}
zip-safe = true
platforms = ["any"]

[tool.setuptools.packages.find]
where = ["src"]

[tool.setuptools.cmdclass]
sdist = "pkg.mod.CustomSdist"

[tool.setuptools.dynamic.version]
attr = "pkg.__version__.VERSION"

[tool.setuptools.dynamic.readme]
file = ["README.md"]
content-type = "text/markdown"

[tool.setuptools.package-data]
"*" = ["*.txt"]

[tool.setuptools.data-files]
"data" = ["_files/*.txt"]

[tool.distutils.sdist]
formats = "gztar"

[tool.distutils.bdist_wheel]
universal = true
"""


def create_example(path, pkg_root):
    pyproject = path / "pyproject.toml"

    files = [
        f"{pkg_root}/pkg/__init__.py",
        "_files/file.txt",
    ]
    if pkg_root != ".":  # flat-layout will raise error for multi-package dist
        # Ensure namespaces are discovered
        files.append(f"{pkg_root}/other/nested/__init__.py")

    for file in files:
        (path / file).parent.mkdir(exist_ok=True, parents=True)
        (path / file).touch()

    pyproject.write_text(EXAMPLE)
    (path / "README.md").write_text("hello world")
    (path / f"{pkg_root}/pkg/mod.py").write_text("class CustomSdist: pass")
    (path / f"{pkg_root}/pkg/__version__.py").write_text("VERSION = (3, 10)")
    (path / f"{pkg_root}/pkg/__main__.py").write_text("def exec(): print('hello')")


def verify_example(config, path, pkg_root):
    pyproject = path / "pyproject.toml"
    pyproject.write_text(tomli_w.dumps(config), encoding="utf-8")
    expanded = expand_configuration(config, path)
    expanded_project = expanded["project"]
    assert read_configuration(pyproject, expand=True) == expanded
    assert expanded_project["version"] == "3.10"
    assert expanded_project["readme"]["text"] == "hello world"
    assert "packages" in expanded["tool"]["setuptools"]
    if pkg_root == ".":
        # Auto-discovery will raise error for multi-package dist
        assert set(expanded["tool"]["setuptools"]["packages"]) == {"pkg"}
    else:
        assert set(expanded["tool"]["setuptools"]["packages"]) == {
            "pkg",
            "other",
            "other.nested",
        }
    assert expanded["tool"]["setuptools"]["include-package-data"] is True
    assert "" in expanded["tool"]["setuptools"]["package-data"]
    assert "*" not in expanded["tool"]["setuptools"]["package-data"]
    assert expanded["tool"]["setuptools"]["data-files"] == [
        ("data", ["_files/file.txt"])
    ]


def test_read_configuration(tmp_path):
    create_example(tmp_path, "src")
    pyproject = tmp_path / "pyproject.toml"

    config = read_configuration(pyproject, expand=False)
    assert config["project"].get("version") is None
    assert config["project"].get("readme") is None

    verify_example(config, tmp_path, "src")


@pytest.mark.parametrize(
    "pkg_root, opts",
    [
        (".", {}),
        ("src", {}),
        ("lib", {"packages": {"find": {"where": ["lib"]}}}),
    ],
)
def test_discovered_package_dir_with_attr_directive_in_config(tmp_path, pkg_root, opts):
    create_example(tmp_path, pkg_root)

    pyproject = tmp_path / "pyproject.toml"

    config = read_configuration(pyproject, expand=False)
    assert config["project"].get("version") is None
    assert config["project"].get("readme") is None
    config["tool"]["setuptools"].pop("packages", None)
    config["tool"]["setuptools"].pop("package-dir", None)

    config["tool"]["setuptools"].update(opts)
    verify_example(config, tmp_path, pkg_root)


ENTRY_POINTS = {
    "console_scripts": {"a": "mod.a:func"},
    "gui_scripts": {"b": "mod.b:func"},
    "other": {"c": "mod.c:func [extra]"},
}


class TestEntryPoints:
    def write_entry_points(self, tmp_path):
        entry_points = ConfigParser()
        entry_points.read_dict(ENTRY_POINTS)
        with open(tmp_path / "entry-points.txt", "w") as f:
            entry_points.write(f)

    def pyproject(self, dynamic=None):
        project = {"dynamic": dynamic or ["scripts", "gui-scripts", "entry-points"]}
        tool = {"dynamic": {"entry-points": {"file": "entry-points.txt"}}}
        return {"project": project, "tool": {"setuptools": tool}}

    def test_all_listed_in_dynamic(self, tmp_path):
        self.write_entry_points(tmp_path)
        expanded = expand_configuration(self.pyproject(), tmp_path)
        expanded_project = expanded["project"]
        assert len(expanded_project["scripts"]) == 1
        assert expanded_project["scripts"]["a"] == "mod.a:func"
        assert len(expanded_project["gui-scripts"]) == 1
        assert expanded_project["gui-scripts"]["b"] == "mod.b:func"
        assert len(expanded_project["entry-points"]) == 1
        assert expanded_project["entry-points"]["other"]["c"] == "mod.c:func [extra]"

    @pytest.mark.parametrize("missing_dynamic", ("scripts", "gui-scripts"))
    def test_scripts_not_listed_in_dynamic(self, tmp_path, missing_dynamic):
        self.write_entry_points(tmp_path)
        dynamic = {"scripts", "gui-scripts", "entry-points"} - {missing_dynamic}

        msg = f"defined outside of `pyproject.toml`:.*{missing_dynamic}"
        with pytest.warns(_WouldIgnoreField, match=re.compile(msg, re.S)):
            expanded = expand_configuration(self.pyproject(dynamic), tmp_path)

        expanded_project = expanded["project"]
        assert dynamic < set(expanded_project)
        assert len(expanded_project["entry-points"]) == 1
        # TODO: Test the following when pyproject.toml support stabilizes:
        # >>> assert missing_dynamic not in expanded_project


class TestClassifiers:
    def test_dynamic(self, tmp_path):
        # Let's create a project example that has dynamic classifiers
        # coming from a txt file.
        create_example(tmp_path, "src")
        classifiers = """\
        Framework :: Flask
        Programming Language :: Haskell
        """
        (tmp_path / "classifiers.txt").write_text(cleandoc(classifiers))

        pyproject = tmp_path / "pyproject.toml"
        config = read_configuration(pyproject, expand=False)
        dynamic = config["project"]["dynamic"]
        config["project"]["dynamic"] = list({*dynamic, "classifiers"})
        dynamic_config = config["tool"]["setuptools"]["dynamic"]
        dynamic_config["classifiers"] = {"file": "classifiers.txt"}

        # When the configuration is expanded,
        # each line of the file should be an different classifier.
        validate(config, pyproject)
        expanded = expand_configuration(config, tmp_path)

        assert set(expanded["project"]["classifiers"]) == {
            "Framework :: Flask",
            "Programming Language :: Haskell",
        }

    def test_dynamic_without_config(self, tmp_path):
        config = """
        [project]
        name = "myproj"
        version = '42'
        dynamic = ["classifiers"]
        """

        pyproject = tmp_path / "pyproject.toml"
        pyproject.write_text(cleandoc(config))
        with pytest.raises(OptionError, match="No configuration .* .classifiers."):
            read_configuration(pyproject)

    def test_dynamic_readme_from_setup_script_args(self, tmp_path):
        config = """
        [project]
        name = "myproj"
        version = '42'
        dynamic = ["readme"]
        """
        pyproject = tmp_path / "pyproject.toml"
        pyproject.write_text(cleandoc(config))
        dist = Distribution(attrs={"long_description": "42"})
        # No error should occur because of missing `readme`
        dist = apply_configuration(dist, pyproject)
        assert dist.metadata.long_description == "42"

    def test_dynamic_without_file(self, tmp_path):
        config = """
        [project]
        name = "myproj"
        version = '42'
        dynamic = ["classifiers"]

        [tool.setuptools.dynamic]
        classifiers = {file = ["classifiers.txt"]}
        """

        pyproject = tmp_path / "pyproject.toml"
        pyproject.write_text(cleandoc(config))
        with pytest.warns(UserWarning, match="File .*classifiers.txt. cannot be found"):
            expanded = read_configuration(pyproject)
        assert "classifiers" not in expanded["project"]


@pytest.mark.parametrize(
    "example",
    (
        """
        [project]
        name = "myproj"
        version = "1.2"

        [my-tool.that-disrespect.pep518]
        value = 42
        """,
    ),
)
def test_ignore_unrelated_config(tmp_path, example):
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text(cleandoc(example))

    # Make sure no error is raised due to 3rd party configs in pyproject.toml
    assert read_configuration(pyproject) is not None


@pytest.mark.parametrize(
    "example, error_msg",
    [
        (
            """
            [project]
            name = "myproj"
            version = "1.2"
            requires = ['pywin32; platform_system=="Windows"' ]
            """,
            "configuration error: .project. must not contain ..requires.. properties",
        ),
    ],
)
def test_invalid_example(tmp_path, example, error_msg):
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text(cleandoc(example))

    pattern = re.compile(f"invalid pyproject.toml.*{error_msg}.*", re.M | re.S)
    with pytest.raises(ValueError, match=pattern):
        read_configuration(pyproject)


@pytest.mark.parametrize("config", ("", "[tool.something]\nvalue = 42"))
def test_empty(tmp_path, config):
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text(config)

    # Make sure no error is raised
    assert read_configuration(pyproject) == {}


@pytest.mark.parametrize("config", ("[project]\nname = 'myproj'\nversion='42'\n",))
def test_include_package_data_by_default(tmp_path, config):
    """Builds with ``pyproject.toml`` should consider ``include-package-data=True`` as
    default.
    """
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text(config)

    config = read_configuration(pyproject)
    assert config["tool"]["setuptools"]["include-package-data"] is True


def test_include_package_data_in_setuppy(tmp_path):
    """Builds with ``pyproject.toml`` should consider ``include_package_data`` set in
    ``setup.py``.

    See https://github.com/pypa/setuptools/issues/3197#issuecomment-1079023889
    """
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text("[project]\nname = 'myproj'\nversion='42'\n")
    setuppy = tmp_path / "setup.py"
    setuppy.write_text("__import__('setuptools').setup(include_package_data=False)")

    with _Path(tmp_path):
        dist = distutils.core.run_setup("setup.py", {}, stop_after="config")

    assert dist.get_name() == "myproj"
    assert dist.get_version() == "42"
    assert dist.include_package_data is False
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py0000644000175100001730000000531214467657412027346 0ustar00runnerdockerimport pytest

from setuptools.config.pyprojecttoml import apply_configuration
from setuptools.dist import Distribution
from setuptools.tests.textwrap import DALS


def test_dynamic_dependencies(tmp_path):
    (tmp_path / "requirements.txt").write_text("six\n  # comment\n")
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text(
        DALS(
            """
    [project]
    name = "myproj"
    version = "1.0"
    dynamic = ["dependencies"]

    [build-system]
    requires = ["setuptools", "wheel"]
    build-backend = "setuptools.build_meta"

    [tool.setuptools.dynamic.dependencies]
    file = ["requirements.txt"]
    """
        )
    )
    dist = Distribution()
    dist = apply_configuration(dist, pyproject)
    assert dist.install_requires == ["six"]


def test_dynamic_optional_dependencies(tmp_path):
    (tmp_path / "requirements-docs.txt").write_text("sphinx\n  # comment\n")
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text(
        DALS(
            """
    [project]
    name = "myproj"
    version = "1.0"
    dynamic = ["optional-dependencies"]

    [tool.setuptools.dynamic.optional-dependencies.docs]
    file = ["requirements-docs.txt"]

    [build-system]
    requires = ["setuptools", "wheel"]
    build-backend = "setuptools.build_meta"
    """
        )
    )
    dist = Distribution()
    dist = apply_configuration(dist, pyproject)
    assert dist.extras_require == {"docs": ["sphinx"]}


def test_mixed_dynamic_optional_dependencies(tmp_path):
    """
    Test that if PEP 621 was loosened to allow mixing of dynamic and static
    configurations in the case of fields containing sub-fields (groups),
    things would work out.
    """
    (tmp_path / "requirements-images.txt").write_text("pillow~=42.0\n  # comment\n")
    pyproject = tmp_path / "pyproject.toml"
    pyproject.write_text(
        DALS(
            """
    [project]
    name = "myproj"
    version = "1.0"
    dynamic = ["optional-dependencies"]

    [project.optional-dependencies]
    docs = ["sphinx"]

    [tool.setuptools.dynamic.optional-dependencies.images]
    file = ["requirements-images.txt"]

    [build-system]
    requires = ["setuptools", "wheel"]
    build-backend = "setuptools.build_meta"
    """
        )
    )
    # Test that the mix-and-match doesn't currently validate.
    with pytest.raises(ValueError, match="project.optional-dependencies"):
        apply_configuration(Distribution(), pyproject)

    # Explicitly disable the validation and try again, to see that the mix-and-match
    # result would be correct.
    dist = Distribution()
    dist = apply_configuration(dist, pyproject, ignore_option_errors=True)
    assert dist.extras_require == {"docs": ["sphinx"], "images": ["pillow~=42.0"]}
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/config/test_setupcfg.py0000644000175100001730000010303214467657412023532 0ustar00runnerdockerimport configparser
import contextlib
import inspect
from pathlib import Path
from unittest.mock import Mock, patch

import pytest

from distutils.errors import DistutilsOptionError, DistutilsFileError
from setuptools.dist import Distribution, _Distribution
from setuptools.config.setupcfg import ConfigHandler, read_configuration
from setuptools.extern.packaging.requirements import InvalidRequirement
from setuptools.warnings import SetuptoolsDeprecationWarning
from ..textwrap import DALS


class ErrConfigHandler(ConfigHandler):
    """Erroneous handler. Fails to implement required methods."""

    section_prefix = "**err**"


def make_package_dir(name, base_dir, ns=False):
    dir_package = base_dir
    for dir_name in name.split('/'):
        dir_package = dir_package.mkdir(dir_name)
    init_file = None
    if not ns:
        init_file = dir_package.join('__init__.py')
        init_file.write('')
    return dir_package, init_file


def fake_env(
    tmpdir, setup_cfg, setup_py=None, encoding='ascii', package_path='fake_package'
):
    if setup_py is None:
        setup_py = 'from setuptools import setup\n' 'setup()\n'

    tmpdir.join('setup.py').write(setup_py)
    config = tmpdir.join('setup.cfg')
    config.write(setup_cfg.encode(encoding), mode='wb')

    package_dir, init_file = make_package_dir(package_path, tmpdir)

    init_file.write(
        'VERSION = (1, 2, 3)\n'
        '\n'
        'VERSION_MAJOR = 1'
        '\n'
        'def get_version():\n'
        '    return [3, 4, 5, "dev"]\n'
        '\n'
    )

    return package_dir, config


@contextlib.contextmanager
def get_dist(tmpdir, kwargs_initial=None, parse=True):
    kwargs_initial = kwargs_initial or {}

    with tmpdir.as_cwd():
        dist = Distribution(kwargs_initial)
        dist.script_name = 'setup.py'
        parse and dist.parse_config_files()

        yield dist


def test_parsers_implemented():
    with pytest.raises(NotImplementedError):
        handler = ErrConfigHandler(None, {}, False, Mock())
        handler.parsers


class TestConfigurationReader:
    def test_basic(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = 10.1.1\n'
            'keywords = one, two\n'
            '\n'
            '[options]\n'
            'scripts = bin/a.py, bin/b.py\n',
        )
        config_dict = read_configuration('%s' % config)
        assert config_dict['metadata']['version'] == '10.1.1'
        assert config_dict['metadata']['keywords'] == ['one', 'two']
        assert config_dict['options']['scripts'] == ['bin/a.py', 'bin/b.py']

    def test_no_config(self, tmpdir):
        with pytest.raises(DistutilsFileError):
            read_configuration('%s' % tmpdir.join('setup.cfg'))

    def test_ignore_errors(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[metadata]\n' 'version = attr: none.VERSION\n' 'keywords = one, two\n',
        )
        with pytest.raises(ImportError):
            read_configuration('%s' % config)

        config_dict = read_configuration('%s' % config, ignore_option_errors=True)

        assert config_dict['metadata']['keywords'] == ['one', 'two']
        assert 'version' not in config_dict['metadata']

        config.remove()


class TestMetadata:
    def test_basic(self, tmpdir):
        fake_env(
            tmpdir,
            '[metadata]\n'
            'version = 10.1.1\n'
            'description = Some description\n'
            'long_description_content_type = text/something\n'
            'long_description = file: README\n'
            'name = fake_name\n'
            'keywords = one, two\n'
            'provides = package, package.sub\n'
            'license = otherlic\n'
            'download_url = http://test.test.com/test/\n'
            'maintainer_email = test@test.com\n',
        )

        tmpdir.join('README').write('readme contents\nline2')

        meta_initial = {
            # This will be used so `otherlic` won't replace it.
            'license': 'BSD 3-Clause License',
        }

        with get_dist(tmpdir, meta_initial) as dist:
            metadata = dist.metadata

            assert metadata.version == '10.1.1'
            assert metadata.description == 'Some description'
            assert metadata.long_description_content_type == 'text/something'
            assert metadata.long_description == 'readme contents\nline2'
            assert metadata.provides == ['package', 'package.sub']
            assert metadata.license == 'BSD 3-Clause License'
            assert metadata.name == 'fake_name'
            assert metadata.keywords == ['one', 'two']
            assert metadata.download_url == 'http://test.test.com/test/'
            assert metadata.maintainer_email == 'test@test.com'

    def test_license_cfg(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [metadata]
            name=foo
            version=0.0.1
            license=Apache 2.0
            """
            ),
        )

        with get_dist(tmpdir) as dist:
            metadata = dist.metadata

            assert metadata.name == "foo"
            assert metadata.version == "0.0.1"
            assert metadata.license == "Apache 2.0"

    def test_file_mixed(self, tmpdir):
        fake_env(
            tmpdir,
            '[metadata]\n' 'long_description = file: README.rst, CHANGES.rst\n' '\n',
        )

        tmpdir.join('README.rst').write('readme contents\nline2')
        tmpdir.join('CHANGES.rst').write('changelog contents\nand stuff')

        with get_dist(tmpdir) as dist:
            assert dist.metadata.long_description == (
                'readme contents\nline2\n' 'changelog contents\nand stuff'
            )

    def test_file_sandboxed(self, tmpdir):
        tmpdir.ensure("README")
        project = tmpdir.join('depth1', 'depth2')
        project.ensure(dir=True)
        fake_env(project, '[metadata]\n' 'long_description = file: ../../README\n')

        with get_dist(project, parse=False) as dist:
            with pytest.raises(DistutilsOptionError):
                dist.parse_config_files()  # file: out of sandbox

    def test_aliases(self, tmpdir):
        fake_env(
            tmpdir,
            '[metadata]\n'
            'author_email = test@test.com\n'
            'home_page = http://test.test.com/test/\n'
            'summary = Short summary\n'
            'platform = a, b\n'
            'classifier =\n'
            '  Framework :: Django\n'
            '  Programming Language :: Python :: 3.5\n',
        )

        with get_dist(tmpdir) as dist:
            metadata = dist.metadata
            assert metadata.author_email == 'test@test.com'
            assert metadata.url == 'http://test.test.com/test/'
            assert metadata.description == 'Short summary'
            assert metadata.platforms == ['a', 'b']
            assert metadata.classifiers == [
                'Framework :: Django',
                'Programming Language :: Python :: 3.5',
            ]

    def test_multiline(self, tmpdir):
        fake_env(
            tmpdir,
            '[metadata]\n'
            'name = fake_name\n'
            'keywords =\n'
            '  one\n'
            '  two\n'
            'classifiers =\n'
            '  Framework :: Django\n'
            '  Programming Language :: Python :: 3.5\n',
        )
        with get_dist(tmpdir) as dist:
            metadata = dist.metadata
            assert metadata.keywords == ['one', 'two']
            assert metadata.classifiers == [
                'Framework :: Django',
                'Programming Language :: Python :: 3.5',
            ]

    def test_dict(self, tmpdir):
        fake_env(
            tmpdir,
            '[metadata]\n'
            'project_urls =\n'
            '  Link One = https://example.com/one/\n'
            '  Link Two = https://example.com/two/\n',
        )
        with get_dist(tmpdir) as dist:
            metadata = dist.metadata
            assert metadata.project_urls == {
                'Link One': 'https://example.com/one/',
                'Link Two': 'https://example.com/two/',
            }

    def test_version(self, tmpdir):
        package_dir, config = fake_env(
            tmpdir, '[metadata]\n' 'version = attr: fake_package.VERSION\n'
        )

        sub_a = package_dir.mkdir('subpkg_a')
        sub_a.join('__init__.py').write('')
        sub_a.join('mod.py').write('VERSION = (2016, 11, 26)')

        sub_b = package_dir.mkdir('subpkg_b')
        sub_b.join('__init__.py').write('')
        sub_b.join('mod.py').write(
            'import third_party_module\n' 'VERSION = (2016, 11, 26)'
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

        config.write('[metadata]\n' 'version = attr: fake_package.get_version\n')
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '3.4.5.dev'

        config.write('[metadata]\n' 'version = attr: fake_package.VERSION_MAJOR\n')
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1'

        config.write(
            '[metadata]\n' 'version = attr: fake_package.subpkg_a.mod.VERSION\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '2016.11.26'

        config.write(
            '[metadata]\n' 'version = attr: fake_package.subpkg_b.mod.VERSION\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '2016.11.26'

    def test_version_file(self, tmpdir):
        _, config = fake_env(
            tmpdir, '[metadata]\n' 'version = file: fake_package/version.txt\n'
        )
        tmpdir.join('fake_package', 'version.txt').write('1.2.3\n')

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

        tmpdir.join('fake_package', 'version.txt').write('1.2.3\n4.5.6\n')
        with pytest.raises(DistutilsOptionError):
            with get_dist(tmpdir) as dist:
                dist.metadata.version

    def test_version_with_package_dir_simple(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = attr: fake_package_simple.VERSION\n'
            '[options]\n'
            'package_dir =\n'
            '    = src\n',
            package_path='src/fake_package_simple',
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

    def test_version_with_package_dir_rename(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = attr: fake_package_rename.VERSION\n'
            '[options]\n'
            'package_dir =\n'
            '    fake_package_rename = fake_dir\n',
            package_path='fake_dir',
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

    def test_version_with_package_dir_complex(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[metadata]\n'
            'version = attr: fake_package_complex.VERSION\n'
            '[options]\n'
            'package_dir =\n'
            '    fake_package_complex = src/fake_dir\n',
            package_path='src/fake_dir',
        )

        with get_dist(tmpdir) as dist:
            assert dist.metadata.version == '1.2.3'

    def test_unknown_meta_item(self, tmpdir):
        fake_env(tmpdir, '[metadata]\n' 'name = fake_name\n' 'unknown = some\n')
        with get_dist(tmpdir, parse=False) as dist:
            dist.parse_config_files()  # Skip unknown.

    def test_usupported_section(self, tmpdir):
        fake_env(tmpdir, '[metadata.some]\n' 'key = val\n')
        with get_dist(tmpdir, parse=False) as dist:
            with pytest.raises(DistutilsOptionError):
                dist.parse_config_files()

    def test_classifiers(self, tmpdir):
        expected = set(
            [
                'Framework :: Django',
                'Programming Language :: Python :: 3',
                'Programming Language :: Python :: 3.5',
            ]
        )

        # From file.
        _, config = fake_env(tmpdir, '[metadata]\n' 'classifiers = file: classifiers\n')

        tmpdir.join('classifiers').write(
            'Framework :: Django\n'
            'Programming Language :: Python :: 3\n'
            'Programming Language :: Python :: 3.5\n'
        )

        with get_dist(tmpdir) as dist:
            assert set(dist.metadata.classifiers) == expected

        # From list notation
        config.write(
            '[metadata]\n'
            'classifiers =\n'
            '    Framework :: Django\n'
            '    Programming Language :: Python :: 3\n'
            '    Programming Language :: Python :: 3.5\n'
        )
        with get_dist(tmpdir) as dist:
            assert set(dist.metadata.classifiers) == expected

    def test_deprecated_config_handlers(self, tmpdir):
        fake_env(
            tmpdir,
            '[metadata]\n'
            'version = 10.1.1\n'
            'description = Some description\n'
            'requires = some, requirement\n',
        )

        with pytest.warns(SetuptoolsDeprecationWarning, match="requires"):
            with get_dist(tmpdir) as dist:
                metadata = dist.metadata

                assert metadata.version == '10.1.1'
                assert metadata.description == 'Some description'
                assert metadata.requires == ['some', 'requirement']

    def test_interpolation(self, tmpdir):
        fake_env(tmpdir, '[metadata]\n' 'description = %(message)s\n')
        with pytest.raises(configparser.InterpolationMissingOptionError):
            with get_dist(tmpdir):
                pass

    def test_non_ascii_1(self, tmpdir):
        fake_env(tmpdir, '[metadata]\n' 'description = éàïôñ\n', encoding='utf-8')
        with get_dist(tmpdir):
            pass

    def test_non_ascii_3(self, tmpdir):
        fake_env(tmpdir, '\n' '# -*- coding: invalid\n')
        with get_dist(tmpdir):
            pass

    def test_non_ascii_4(self, tmpdir):
        fake_env(
            tmpdir,
            '# -*- coding: utf-8\n' '[metadata]\n' 'description = éàïôñ\n',
            encoding='utf-8',
        )
        with get_dist(tmpdir) as dist:
            assert dist.metadata.description == 'éàïôñ'

    def test_not_utf8(self, tmpdir):
        """
        Config files encoded not in UTF-8 will fail
        """
        fake_env(
            tmpdir,
            '# vim: set fileencoding=iso-8859-15 :\n'
            '[metadata]\n'
            'description = éàïôñ\n',
            encoding='iso-8859-15',
        )
        with pytest.raises(UnicodeDecodeError):
            with get_dist(tmpdir):
                pass

    def test_warn_dash_deprecation(self, tmpdir):
        # warn_dash_deprecation() is a method in setuptools.dist
        # remove this test and the method when no longer needed
        fake_env(
            tmpdir,
            '[metadata]\n'
            'author-email = test@test.com\n'
            'maintainer_email = foo@foo.com\n',
        )
        msg = "Usage of dash-separated 'author-email' will not be supported"
        with pytest.warns(SetuptoolsDeprecationWarning, match=msg):
            with get_dist(tmpdir) as dist:
                metadata = dist.metadata

        assert metadata.author_email == 'test@test.com'
        assert metadata.maintainer_email == 'foo@foo.com'

    def test_make_option_lowercase(self, tmpdir):
        # remove this test and the method make_option_lowercase() in setuptools.dist
        # when no longer needed
        fake_env(
            tmpdir, '[metadata]\n' 'Name = foo\n' 'description = Some description\n'
        )
        msg = "Usage of uppercase key 'Name' in 'metadata' will not be supported"
        with pytest.warns(SetuptoolsDeprecationWarning, match=msg):
            with get_dist(tmpdir) as dist:
                metadata = dist.metadata

        assert metadata.name == 'foo'
        assert metadata.description == 'Some description'


class TestOptions:
    def test_basic(self, tmpdir):
        fake_env(
            tmpdir,
            '[options]\n'
            'zip_safe = True\n'
            'include_package_data = yes\n'
            'package_dir = b=c, =src\n'
            'packages = pack_a, pack_b.subpack\n'
            'namespace_packages = pack1, pack2\n'
            'scripts = bin/one.py, bin/two.py\n'
            'eager_resources = bin/one.py, bin/two.py\n'
            'install_requires = docutils>=0.3; pack ==1.1, ==1.3; hey\n'
            'tests_require = mock==0.7.2; pytest\n'
            'setup_requires = docutils>=0.3; spack ==1.1, ==1.3; there\n'
            'dependency_links = http://some.com/here/1, '
            'http://some.com/there/2\n'
            'python_requires = >=1.0, !=2.8\n'
            'py_modules = module1, module2\n',
        )
        deprec = pytest.warns(SetuptoolsDeprecationWarning, match="namespace_packages")
        with deprec, get_dist(tmpdir) as dist:
            assert dist.zip_safe
            assert dist.include_package_data
            assert dist.package_dir == {'': 'src', 'b': 'c'}
            assert dist.packages == ['pack_a', 'pack_b.subpack']
            assert dist.namespace_packages == ['pack1', 'pack2']
            assert dist.scripts == ['bin/one.py', 'bin/two.py']
            assert dist.dependency_links == (
                ['http://some.com/here/1', 'http://some.com/there/2']
            )
            assert dist.install_requires == (
                ['docutils>=0.3', 'pack==1.1,==1.3', 'hey']
            )
            assert dist.setup_requires == (
                ['docutils>=0.3', 'spack ==1.1, ==1.3', 'there']
            )
            assert dist.tests_require == ['mock==0.7.2', 'pytest']
            assert dist.python_requires == '>=1.0, !=2.8'
            assert dist.py_modules == ['module1', 'module2']

    def test_multiline(self, tmpdir):
        fake_env(
            tmpdir,
            '[options]\n'
            'package_dir = \n'
            '  b=c\n'
            '  =src\n'
            'packages = \n'
            '  pack_a\n'
            '  pack_b.subpack\n'
            'namespace_packages = \n'
            '  pack1\n'
            '  pack2\n'
            'scripts = \n'
            '  bin/one.py\n'
            '  bin/two.py\n'
            'eager_resources = \n'
            '  bin/one.py\n'
            '  bin/two.py\n'
            'install_requires = \n'
            '  docutils>=0.3\n'
            '  pack ==1.1, ==1.3\n'
            '  hey\n'
            'tests_require = \n'
            '  mock==0.7.2\n'
            '  pytest\n'
            'setup_requires = \n'
            '  docutils>=0.3\n'
            '  spack ==1.1, ==1.3\n'
            '  there\n'
            'dependency_links = \n'
            '  http://some.com/here/1\n'
            '  http://some.com/there/2\n',
        )
        deprec = pytest.warns(SetuptoolsDeprecationWarning, match="namespace_packages")
        with deprec, get_dist(tmpdir) as dist:
            assert dist.package_dir == {'': 'src', 'b': 'c'}
            assert dist.packages == ['pack_a', 'pack_b.subpack']
            assert dist.namespace_packages == ['pack1', 'pack2']
            assert dist.scripts == ['bin/one.py', 'bin/two.py']
            assert dist.dependency_links == (
                ['http://some.com/here/1', 'http://some.com/there/2']
            )
            assert dist.install_requires == (
                ['docutils>=0.3', 'pack==1.1,==1.3', 'hey']
            )
            assert dist.setup_requires == (
                ['docutils>=0.3', 'spack ==1.1, ==1.3', 'there']
            )
            assert dist.tests_require == ['mock==0.7.2', 'pytest']

    def test_package_dir_fail(self, tmpdir):
        fake_env(tmpdir, '[options]\n' 'package_dir = a b\n')
        with get_dist(tmpdir, parse=False) as dist:
            with pytest.raises(DistutilsOptionError):
                dist.parse_config_files()

    def test_package_data(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.package_data]\n'
            '* = *.txt, *.rst\n'
            'hello = *.msg\n'
            '\n'
            '[options.exclude_package_data]\n'
            '* = fake1.txt, fake2.txt\n'
            'hello = *.dat\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.package_data == {
                '': ['*.txt', '*.rst'],
                'hello': ['*.msg'],
            }
            assert dist.exclude_package_data == {
                '': ['fake1.txt', 'fake2.txt'],
                'hello': ['*.dat'],
            }

    def test_packages(self, tmpdir):
        fake_env(tmpdir, '[options]\n' 'packages = find:\n')

        with get_dist(tmpdir) as dist:
            assert dist.packages == ['fake_package']

    def test_find_directive(self, tmpdir):
        dir_package, config = fake_env(tmpdir, '[options]\n' 'packages = find:\n')

        dir_sub_one, _ = make_package_dir('sub_one', dir_package)
        dir_sub_two, _ = make_package_dir('sub_two', dir_package)

        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == set(
                ['fake_package', 'fake_package.sub_two', 'fake_package.sub_one']
            )

        config.write(
            '[options]\n'
            'packages = find:\n'
            '\n'
            '[options.packages.find]\n'
            'where = .\n'
            'include =\n'
            '    fake_package.sub_one\n'
            '    two\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.packages == ['fake_package.sub_one']

        config.write(
            '[options]\n'
            'packages = find:\n'
            '\n'
            '[options.packages.find]\n'
            'exclude =\n'
            '    fake_package.sub_one\n'
        )
        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == set(['fake_package', 'fake_package.sub_two'])

    def test_find_namespace_directive(self, tmpdir):
        dir_package, config = fake_env(
            tmpdir, '[options]\n' 'packages = find_namespace:\n'
        )

        dir_sub_one, _ = make_package_dir('sub_one', dir_package)
        dir_sub_two, _ = make_package_dir('sub_two', dir_package, ns=True)

        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == {
                'fake_package',
                'fake_package.sub_two',
                'fake_package.sub_one',
            }

        config.write(
            '[options]\n'
            'packages = find_namespace:\n'
            '\n'
            '[options.packages.find]\n'
            'where = .\n'
            'include =\n'
            '    fake_package.sub_one\n'
            '    two\n'
        )
        with get_dist(tmpdir) as dist:
            assert dist.packages == ['fake_package.sub_one']

        config.write(
            '[options]\n'
            'packages = find_namespace:\n'
            '\n'
            '[options.packages.find]\n'
            'exclude =\n'
            '    fake_package.sub_one\n'
        )
        with get_dist(tmpdir) as dist:
            assert set(dist.packages) == {'fake_package', 'fake_package.sub_two'}

    def test_extras_require(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.extras_require]\n'
            'pdf = ReportLab>=1.2; RXP\n'
            'rest = \n'
            '  docutils>=0.3\n'
            '  pack ==1.1, ==1.3\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.extras_require == {
                'pdf': ['ReportLab>=1.2', 'RXP'],
                'rest': ['docutils>=0.3', 'pack==1.1,==1.3'],
            }
            assert dist.metadata.provides_extras == set(['pdf', 'rest'])

    @pytest.mark.parametrize(
        "config",
        [
            "[options.extras_require]\nfoo = bar;python_version<'3'",
            "[options.extras_require]\nfoo = bar;os_name=='linux'",
            "[options.extras_require]\nfoo = bar;python_version<'3'\n",
            "[options.extras_require]\nfoo = bar;os_name=='linux'\n",
            "[options]\ninstall_requires = bar;python_version<'3'",
            "[options]\ninstall_requires = bar;os_name=='linux'",
            "[options]\ninstall_requires = bar;python_version<'3'\n",
            "[options]\ninstall_requires = bar;os_name=='linux'\n",
        ],
    )
    def test_raises_accidental_env_marker_misconfig(self, config, tmpdir):
        fake_env(tmpdir, config)
        match = (
            r"One of the parsed requirements in `(install_requires|extras_require.+)` "
            "looks like a valid environment marker.*"
        )
        with pytest.raises(InvalidRequirement, match=match):
            with get_dist(tmpdir) as _:
                pass

    @pytest.mark.parametrize(
        "config",
        [
            "[options.extras_require]\nfoo = bar;python_version<3",
            "[options.extras_require]\nfoo = bar;python_version<3\n",
            "[options]\ninstall_requires = bar;python_version<3",
            "[options]\ninstall_requires = bar;python_version<3\n",
        ],
    )
    def test_warn_accidental_env_marker_misconfig(self, config, tmpdir):
        fake_env(tmpdir, config)
        match = (
            r"One of the parsed requirements in `(install_requires|extras_require.+)` "
            "looks like a valid environment marker.*"
        )
        with pytest.warns(SetuptoolsDeprecationWarning, match=match):
            with get_dist(tmpdir) as _:
                pass

    @pytest.mark.parametrize(
        "config",
        [
            "[options.extras_require]\nfoo =\n    bar;python_version<'3'",
            "[options.extras_require]\nfoo = bar;baz\nboo = xxx;yyy",
            "[options.extras_require]\nfoo =\n    bar;python_version<'3'\n",
            "[options.extras_require]\nfoo = bar;baz\nboo = xxx;yyy\n",
            "[options.extras_require]\nfoo =\n    bar\n    python_version<3\n",
            "[options]\ninstall_requires =\n    bar;python_version<'3'",
            "[options]\ninstall_requires = bar;baz\nboo = xxx;yyy",
            "[options]\ninstall_requires =\n    bar;python_version<'3'\n",
            "[options]\ninstall_requires = bar;baz\nboo = xxx;yyy\n",
            "[options]\ninstall_requires =\n    bar\n    python_version<3\n",
        ],
    )
    @pytest.mark.filterwarnings("error::setuptools.SetuptoolsDeprecationWarning")
    def test_nowarn_accidental_env_marker_misconfig(self, config, tmpdir, recwarn):
        fake_env(tmpdir, config)
        num_warnings = len(recwarn)
        with get_dist(tmpdir) as _:
            pass
        # The examples are valid, no warnings shown
        assert len(recwarn) == num_warnings

    def test_dash_preserved_extras_require(self, tmpdir):
        fake_env(tmpdir, '[options.extras_require]\n' 'foo-a = foo\n' 'foo_b = test\n')

        with get_dist(tmpdir) as dist:
            assert dist.extras_require == {'foo-a': ['foo'], 'foo_b': ['test']}

    def test_entry_points(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[options.entry_points]\n'
            'group1 = point1 = pack.module:func, '
            '.point2 = pack.module2:func_rest [rest]\n'
            'group2 = point3 = pack.module:func2\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.entry_points == {
                'group1': [
                    'point1 = pack.module:func',
                    '.point2 = pack.module2:func_rest [rest]',
                ],
                'group2': ['point3 = pack.module:func2'],
            }

        expected = (
            '[blogtool.parsers]\n'
            '.rst = some.nested.module:SomeClass.some_classmethod[reST]\n'
        )

        tmpdir.join('entry_points').write(expected)

        # From file.
        config.write('[options]\n' 'entry_points = file: entry_points\n')

        with get_dist(tmpdir) as dist:
            assert dist.entry_points == expected

    def test_case_sensitive_entry_points(self, tmpdir):
        _, config = fake_env(
            tmpdir,
            '[options.entry_points]\n'
            'GROUP1 = point1 = pack.module:func, '
            '.point2 = pack.module2:func_rest [rest]\n'
            'group2 = point3 = pack.module:func2\n',
        )

        with get_dist(tmpdir) as dist:
            assert dist.entry_points == {
                'GROUP1': [
                    'point1 = pack.module:func',
                    '.point2 = pack.module2:func_rest [rest]',
                ],
                'group2': ['point3 = pack.module:func2'],
            }

    def test_data_files(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.data_files]\n'
            'cfg =\n'
            '      a/b.conf\n'
            '      c/d.conf\n'
            'data = e/f.dat, g/h.dat\n',
        )

        with get_dist(tmpdir) as dist:
            expected = [
                ('cfg', ['a/b.conf', 'c/d.conf']),
                ('data', ['e/f.dat', 'g/h.dat']),
            ]
            assert sorted(dist.data_files) == sorted(expected)

    def test_data_files_globby(self, tmpdir):
        fake_env(
            tmpdir,
            '[options.data_files]\n'
            'cfg =\n'
            '      a/b.conf\n'
            '      c/d.conf\n'
            'data = *.dat\n'
            'icons = \n'
            '      *.ico\n'
            'audio = \n'
            '      *.wav\n'
            '      sounds.db\n',
        )

        # Create dummy files for glob()'s sake:
        tmpdir.join('a.dat').write('')
        tmpdir.join('b.dat').write('')
        tmpdir.join('c.dat').write('')
        tmpdir.join('a.ico').write('')
        tmpdir.join('b.ico').write('')
        tmpdir.join('c.ico').write('')
        tmpdir.join('beep.wav').write('')
        tmpdir.join('boop.wav').write('')
        tmpdir.join('sounds.db').write('')

        with get_dist(tmpdir) as dist:
            expected = [
                ('cfg', ['a/b.conf', 'c/d.conf']),
                ('data', ['a.dat', 'b.dat', 'c.dat']),
                ('icons', ['a.ico', 'b.ico', 'c.ico']),
                ('audio', ['beep.wav', 'boop.wav', 'sounds.db']),
            ]
            assert sorted(dist.data_files) == sorted(expected)

    def test_python_requires_simple(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [options]
            python_requires=>=2.7
            """
            ),
        )
        with get_dist(tmpdir) as dist:
            dist.parse_config_files()

    def test_python_requires_compound(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [options]
            python_requires=>=2.7,!=3.0.*
            """
            ),
        )
        with get_dist(tmpdir) as dist:
            dist.parse_config_files()

    def test_python_requires_invalid(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [options]
            python_requires=invalid
            """
            ),
        )
        with pytest.raises(Exception):
            with get_dist(tmpdir) as dist:
                dist.parse_config_files()

    def test_cmdclass(self, tmpdir):
        module_path = Path(tmpdir, "src/custom_build.py")  # auto discovery for src
        module_path.parent.mkdir(parents=True, exist_ok=True)
        module_path.write_text(
            "from distutils.core import Command\n" "class CustomCmd(Command): pass\n"
        )

        setup_cfg = """
            [options]
            cmdclass =
                customcmd = custom_build.CustomCmd
        """
        fake_env(tmpdir, inspect.cleandoc(setup_cfg))

        with get_dist(tmpdir) as dist:
            cmdclass = dist.cmdclass['customcmd']
            assert cmdclass.__name__ == "CustomCmd"
            assert cmdclass.__module__ == "custom_build"
            assert module_path.samefile(inspect.getfile(cmdclass))

    def test_requirements_file(self, tmpdir):
        fake_env(
            tmpdir,
            DALS(
                """
            [options]
            install_requires = file:requirements.txt
            [options.extras_require]
            colors = file:requirements-extra.txt
            """
            ),
        )

        tmpdir.join('requirements.txt').write('\ndocutils>=0.3\n\n')
        tmpdir.join('requirements-extra.txt').write('colorama')

        with get_dist(tmpdir) as dist:
            assert dist.install_requires == ['docutils>=0.3']
            assert dist.extras_require == {'colors': ['colorama']}


saved_dist_init = _Distribution.__init__


class TestExternalSetters:
    # During creation of the setuptools Distribution() object, we call
    # the init of the parent distutils Distribution object via
    # _Distribution.__init__ ().
    #
    # It's possible distutils calls out to various keyword
    # implementations (i.e. distutils.setup_keywords entry points)
    # that may set a range of variables.
    #
    # This wraps distutil's Distribution.__init__ and simulates
    # pbr or something else setting these values.
    def _fake_distribution_init(self, dist, attrs):
        saved_dist_init(dist, attrs)
        # see self._DISTUTUILS_UNSUPPORTED_METADATA
        setattr(dist.metadata, 'long_description_content_type', 'text/something')
        # Test overwrite setup() args
        setattr(
            dist.metadata,
            'project_urls',
            {
                'Link One': 'https://example.com/one/',
                'Link Two': 'https://example.com/two/',
            },
        )
        return None

    @patch.object(_Distribution, '__init__', autospec=True)
    def test_external_setters(self, mock_parent_init, tmpdir):
        mock_parent_init.side_effect = self._fake_distribution_init

        dist = Distribution(attrs={'project_urls': {'will_be': 'ignored'}})

        assert dist.metadata.long_description_content_type == 'text/something'
        assert dist.metadata.project_urls == {
            'Link One': 'https://example.com/one/',
            'Link Two': 'https://example.com/two/',
        }
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/contexts.py0000644000175100001730000000663014467657412021263 0ustar00runnerdockerimport tempfile
import os
import shutil
import sys
import contextlib
import site
import io

from filelock import FileLock


@contextlib.contextmanager
def tempdir(cd=lambda dir: None, **kwargs):
    temp_dir = tempfile.mkdtemp(**kwargs)
    orig_dir = os.getcwd()
    try:
        cd(temp_dir)
        yield temp_dir
    finally:
        cd(orig_dir)
        shutil.rmtree(temp_dir)


@contextlib.contextmanager
def environment(**replacements):
    """
    In a context, patch the environment with replacements. Pass None values
    to clear the values.
    """
    saved = dict((key, os.environ[key]) for key in replacements if key in os.environ)

    # remove values that are null
    remove = (key for (key, value) in replacements.items() if value is None)
    for key in list(remove):
        os.environ.pop(key, None)
        replacements.pop(key)

    os.environ.update(replacements)

    try:
        yield saved
    finally:
        for key in replacements:
            os.environ.pop(key, None)
        os.environ.update(saved)


@contextlib.contextmanager
def quiet():
    """
    Redirect stdout/stderr to StringIO objects to prevent console output from
    distutils commands.
    """

    old_stdout = sys.stdout
    old_stderr = sys.stderr
    new_stdout = sys.stdout = io.StringIO()
    new_stderr = sys.stderr = io.StringIO()
    try:
        yield new_stdout, new_stderr
    finally:
        new_stdout.seek(0)
        new_stderr.seek(0)
        sys.stdout = old_stdout
        sys.stderr = old_stderr


@contextlib.contextmanager
def save_user_site_setting():
    saved = site.ENABLE_USER_SITE
    try:
        yield saved
    finally:
        site.ENABLE_USER_SITE = saved


@contextlib.contextmanager
def save_pkg_resources_state():
    import pkg_resources

    pr_state = pkg_resources.__getstate__()
    # also save sys.path
    sys_path = sys.path[:]
    try:
        yield pr_state, sys_path
    finally:
        sys.path[:] = sys_path
        pkg_resources.__setstate__(pr_state)


@contextlib.contextmanager
def suppress_exceptions(*excs):
    try:
        yield
    except excs:
        pass


def multiproc(request):
    """
    Return True if running under xdist and multiple
    workers are used.
    """
    try:
        worker_id = request.getfixturevalue('worker_id')
    except Exception:
        return False
    return worker_id != 'master'


@contextlib.contextmanager
def session_locked_tmp_dir(request, tmp_path_factory, name):
    """Uses a file lock to guarantee only one worker can access a temp dir"""
    # get the temp directory shared by all workers
    base = tmp_path_factory.getbasetemp()
    shared_dir = base.parent if multiproc(request) else base

    locked_dir = shared_dir / name
    with FileLock(locked_dir.with_suffix(".lock")):
        # ^-- prevent multiple workers to access the directory at once
        locked_dir.mkdir(exist_ok=True, parents=True)
        yield locked_dir


@contextlib.contextmanager
def save_paths():
    """Make sure ``sys.path``, ``sys.meta_path`` and ``sys.path_hooks`` are preserved"""
    prev = sys.path[:], sys.meta_path[:], sys.path_hooks[:]

    try:
        yield
    finally:
        sys.path, sys.meta_path, sys.path_hooks = prev


@contextlib.contextmanager
def save_sys_modules():
    """Make sure initial ``sys.modules`` is preserved"""
    prev_modules = sys.modules

    try:
        sys.modules = sys.modules.copy()
        yield
    finally:
        sys.modules = prev_modules
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/environment.py0000644000175100001730000000575214467657412021764 0ustar00runnerdockerimport os
import sys
import subprocess
import unicodedata
from subprocess import Popen as _Popen, PIPE as _PIPE

import jaraco.envs


class VirtualEnv(jaraco.envs.VirtualEnv):
    name = '.env'
    # Some version of PyPy will import distutils on startup, implicitly
    # importing setuptools, and thus leading to BackendInvalid errors
    # when upgrading Setuptools. Bypass this behavior by avoiding the
    # early availability and need to upgrade.
    create_opts = ['--no-setuptools']

    def run(self, cmd, *args, **kwargs):
        cmd = [self.exe(cmd[0])] + cmd[1:]
        kwargs = {"cwd": self.root, **kwargs}  # Allow overriding
        # In some environments (eg. downstream distro packaging), where:
        # - tox isn't used to run tests and
        # - PYTHONPATH is set to point to a specific setuptools codebase and
        # - no custom env is explicitly set by a test
        # PYTHONPATH will leak into the spawned processes.
        # In that case tests look for module in the wrong place (on PYTHONPATH).
        # Unless the test sets its own special env, pass a copy of the existing
        # environment with removed PYTHONPATH to the subprocesses.
        if "env" not in kwargs:
            env = dict(os.environ)
            if "PYTHONPATH" in env:
                del env["PYTHONPATH"]
            kwargs["env"] = env
        return subprocess.check_output(cmd, *args, **kwargs)


def _which_dirs(cmd):
    result = set()
    for path in os.environ.get('PATH', '').split(os.pathsep):
        filename = os.path.join(path, cmd)
        if os.access(filename, os.X_OK):
            result.add(path)
    return result


def run_setup_py(cmd, pypath=None, path=None, data_stream=0, env=None):
    """
    Execution command for tests, separate from those used by the
    code directly to prevent accidental behavior issues
    """
    if env is None:
        env = dict()
        for envname in os.environ:
            env[envname] = os.environ[envname]

    # override the python path if needed
    if pypath is not None:
        env["PYTHONPATH"] = pypath

    # override the execution path if needed
    if path is not None:
        env["PATH"] = path
    if not env.get("PATH", ""):
        env["PATH"] = _which_dirs("tar").union(_which_dirs("gzip"))
        env["PATH"] = os.pathsep.join(env["PATH"])

    cmd = [sys.executable, "setup.py"] + list(cmd)

    # http://bugs.python.org/issue8557
    shell = sys.platform == 'win32'

    try:
        proc = _Popen(
            cmd,
            stdout=_PIPE,
            stderr=_PIPE,
            shell=shell,
            env=env,
        )

        if isinstance(data_stream, tuple):
            data_stream = slice(*data_stream)
        data = proc.communicate()[data_stream]
    except OSError:
        return 1, ''

    # decode the console string if needed
    if hasattr(data, "decode"):
        # use the default encoding
        data = data.decode()
        data = unicodedata.normalize('NFC', data)

    # communicate calls wait()
    return proc.returncode, data
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/fixtures.py0000644000175100001730000001130314467657412021256 0ustar00runnerdockerimport os
import contextlib
import sys
import subprocess
from pathlib import Path

import pytest
import path

from . import contexts, environment


@pytest.fixture
def user_override(monkeypatch):
    """
    Override site.USER_BASE and site.USER_SITE with temporary directories in
    a context.
    """
    with contexts.tempdir() as user_base:
        monkeypatch.setattr('site.USER_BASE', user_base)
        with contexts.tempdir() as user_site:
            monkeypatch.setattr('site.USER_SITE', user_site)
            with contexts.save_user_site_setting():
                yield


@pytest.fixture
def tmpdir_cwd(tmpdir):
    with tmpdir.as_cwd() as orig:
        yield orig


@pytest.fixture(autouse=True, scope="session")
def workaround_xdist_376(request):
    """
    Workaround pytest-dev/pytest-xdist#376

    ``pytest-xdist`` tends to inject '' into ``sys.path``,
    which may break certain isolation expectations.
    Remove the entry so the import
    machinery behaves the same irrespective of xdist.
    """
    if not request.config.pluginmanager.has_plugin('xdist'):
        return

    with contextlib.suppress(ValueError):
        sys.path.remove('')


@pytest.fixture
def sample_project(tmp_path):
    """
    Clone the 'sampleproject' and return a path to it.
    """
    cmd = ['git', 'clone', 'https://github.com/pypa/sampleproject']
    try:
        subprocess.check_call(cmd, cwd=str(tmp_path))
    except Exception:
        pytest.skip("Unable to clone sampleproject")
    return tmp_path / 'sampleproject'


# sdist and wheel artifacts should be stable across a round of tests
# so we can build them once per session and use the files as "readonly"


@pytest.fixture(scope="session")
def setuptools_sdist(tmp_path_factory, request):
    if os.getenv("PRE_BUILT_SETUPTOOLS_SDIST"):
        return Path(os.getenv("PRE_BUILT_SETUPTOOLS_SDIST")).resolve()

    with contexts.session_locked_tmp_dir(
        request, tmp_path_factory, "sdist_build"
    ) as tmp:
        dist = next(tmp.glob("*.tar.gz"), None)
        if dist:
            return dist

        subprocess.check_call(
            [
                sys.executable,
                "-m",
                "build",
                "--sdist",
                "--outdir",
                str(tmp),
                str(request.config.rootdir),
            ]
        )
        return next(tmp.glob("*.tar.gz"))


@pytest.fixture(scope="session")
def setuptools_wheel(tmp_path_factory, request):
    if os.getenv("PRE_BUILT_SETUPTOOLS_WHEEL"):
        return Path(os.getenv("PRE_BUILT_SETUPTOOLS_WHEEL")).resolve()

    with contexts.session_locked_tmp_dir(
        request, tmp_path_factory, "wheel_build"
    ) as tmp:
        dist = next(tmp.glob("*.whl"), None)
        if dist:
            return dist

        subprocess.check_call(
            [
                sys.executable,
                "-m",
                "build",
                "--wheel",
                "--outdir",
                str(tmp),
                str(request.config.rootdir),
            ]
        )
        return next(tmp.glob("*.whl"))


@pytest.fixture
def venv(tmp_path, setuptools_wheel):
    """Virtual env with the version of setuptools under test installed"""
    env = environment.VirtualEnv()
    env.root = path.Path(tmp_path / 'venv')
    env.create_opts = ['--no-setuptools', '--wheel=bundle']
    # TODO: Use `--no-wheel` when setuptools implements its own bdist_wheel
    env.req = str(setuptools_wheel)
    # In some environments (eg. downstream distro packaging),
    # where tox isn't used to run tests and PYTHONPATH is set to point to
    # a specific setuptools codebase, PYTHONPATH will leak into the spawned
    # processes.
    # env.create() should install the just created setuptools
    # wheel, but it doesn't if it finds another existing matching setuptools
    # installation present on PYTHONPATH:
    # `setuptools is already installed with the same version as the provided
    # wheel. Use --force-reinstall to force an installation of the wheel.`
    # This prevents leaking PYTHONPATH to the created environment.
    with contexts.environment(PYTHONPATH=None):
        return env.create()


@pytest.fixture
def venv_without_setuptools(tmp_path):
    """Virtual env without any version of setuptools installed"""
    env = environment.VirtualEnv()
    env.root = path.Path(tmp_path / 'venv_without_setuptools')
    env.create_opts = ['--no-setuptools', '--no-wheel']
    env.ensure_env()
    return env


@pytest.fixture
def bare_venv(tmp_path):
    """Virtual env without any common packages installed"""
    env = environment.VirtualEnv()
    env.root = path.Path(tmp_path / 'bare_venv')
    env.create_opts = ['--no-setuptools', '--no-pip', '--no-wheel', '--no-seed']
    env.ensure_env()
    return env
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4795473
setuptools-68.1.2/setuptools/tests/indexes/0000755000175100001730000000000014467657443020500 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5515513
setuptools-68.1.2/setuptools/tests/indexes/test_links_priority/0000755000175100001730000000000014467657444024621 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/indexes/test_links_priority/external.html0000644000175100001730000000013414467657412027322 0ustar00runnerdocker
bad old link

././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.4795473
setuptools-68.1.2/setuptools/tests/indexes/test_links_priority/simple/0000755000175100001730000000000014467657443026111 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5515513
setuptools-68.1.2/setuptools/tests/indexes/test_links_priority/simple/foobar/0000755000175100001730000000000014467657444027362 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/indexes/test_links_priority/simple/foobar/index.html0000644000175100001730000000025614467657412031355 0ustar00runnerdocker
foobar-0.1.tar.gz

external homepage


././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5515513
setuptools-68.1.2/setuptools/tests/integration/0000755000175100001730000000000014467657444021365 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/integration/__init__.py0000644000175100001730000000000014467657412023457 0ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/integration/helpers.py0000644000175100001730000000475714467657412023411 0ustar00runnerdocker"""Reusable functions and classes for different types of integration tests.

For example ``Archive`` can be used to check the contents of distribution built
with setuptools, and ``run`` will always try to be as verbose as possible to
facilitate debugging.
"""
import os
import subprocess
import tarfile
from zipfile import ZipFile
from pathlib import Path


def run(cmd, env=None):
    r = subprocess.run(
        cmd,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        universal_newlines=True,
        env={**os.environ, **(env or {})}
        # ^-- allow overwriting instead of discarding the current env
    )

    out = r.stdout + "\n" + r.stderr
    # pytest omits stdout/err by default, if the test fails they help debugging
    print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
    print(f"Command: {cmd}\nreturn code: {r.returncode}\n\n{out}")

    if r.returncode == 0:
        return out
    raise subprocess.CalledProcessError(r.returncode, cmd, r.stdout, r.stderr)


class Archive:
    """Compatibility layer for ZipFile/Info and TarFile/Info"""

    def __init__(self, filename):
        self._filename = filename
        if filename.endswith("tar.gz"):
            self._obj = tarfile.open(filename, "r:gz")
        elif filename.endswith("zip"):
            self._obj = ZipFile(filename)
        else:
            raise ValueError(f"{filename} doesn't seem to be a zip or tar.gz")

    def __iter__(self):
        if hasattr(self._obj, "infolist"):
            return iter(self._obj.infolist())
        return iter(self._obj)

    def get_name(self, zip_or_tar_info):
        if hasattr(zip_or_tar_info, "filename"):
            return zip_or_tar_info.filename
        return zip_or_tar_info.name

    def get_content(self, zip_or_tar_info):
        if hasattr(self._obj, "extractfile"):
            content = self._obj.extractfile(zip_or_tar_info)
            if content is None:
                msg = f"Invalid {zip_or_tar_info.name} in {self._filename}"
                raise ValueError(msg)
            return str(content.read(), "utf-8")
        return str(self._obj.read(zip_or_tar_info), "utf-8")


def get_sdist_members(sdist_path):
    with tarfile.open(sdist_path, "r:gz") as tar:
        files = [Path(f) for f in tar.getnames()]
    # remove root folder
    relative_files = ("/".join(f.parts[1:]) for f in files)
    return {f for f in relative_files if f}


def get_wheel_members(wheel_path):
    with ZipFile(wheel_path) as zipfile:
        return set(zipfile.namelist())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/integration/test_pip_install_sdist.py0000644000175100001730000001675114467657412026527 0ustar00runnerdocker"""Integration tests for setuptools that focus on building packages via pip.

The idea behind these tests is not to exhaustively check all the possible
combinations of packages, operating systems, supporting libraries, etc, but
rather check a limited number of popular packages and how they interact with
the exposed public API. This way if any change in API is introduced, we hope to
identify backward compatibility problems before publishing a release.

The number of tested packages is purposefully kept small, to minimise duration
and the associated maintenance cost (changes in the way these packages define
their build process may require changes in the tests).
"""
import json
import os
import shutil
import sys
from enum import Enum
from glob import glob
from hashlib import md5
from urllib.request import urlopen

import pytest
from packaging.requirements import Requirement

from .helpers import Archive, run


pytestmark = pytest.mark.integration

(LATEST,) = Enum("v", "LATEST")
"""Default version to be checked"""
# There are positive and negative aspects of checking the latest version of the
# packages.
# The main positive aspect is that the latest version might have already
# removed the use of APIs deprecated in previous releases of setuptools.


# Packages to be tested:
# (Please notice the test environment cannot support EVERY library required for
# compiling binary extensions. In Ubuntu/Debian nomenclature, we only assume
# that `build-essential`, `gfortran` and `libopenblas-dev` are installed,
# due to their relevance to the numerical/scientific programming ecosystem)
EXAMPLES = [
    ("pandas", LATEST),  # cython + custom build_ext
    ("pip", LATEST),  # just in case...
    ("pytest", LATEST),  # uses setuptools_scm
    ("mypy", LATEST),  # custom build_py + ext_modules
    # --- Popular packages: https://hugovk.github.io/top-pypi-packages/ ---
    ("botocore", LATEST),
    ("kiwisolver", "1.3.2"),  # build_ext, version pinned due to setup_requires
    ("brotli", LATEST),  # not in the list but used by urllib3
    # When adding packages to this list, make sure they expose a `__version__`
    # attribute, or modify the tests below
]


# Some packages have "optional" dependencies that modify their build behaviour
# and are not listed in pyproject.toml, others still use `setup_requires`
EXTRA_BUILD_DEPS = {"sphinx": ("babel>=1.3",), "kiwisolver": ("cppy>=1.1.0",)}


VIRTUALENV = (sys.executable, "-m", "virtualenv")


# By default, pip will try to build packages in isolation (PEP 517), which
# means it will download the previous stable version of setuptools.
# `pip` flags can avoid that (the version of setuptools under test
# should be the one to be used)
INSTALL_OPTIONS = (
    "--ignore-installed",
    "--no-build-isolation",
    # Omit "--no-binary :all:" the sdist is supplied directly.
    # Allows dependencies as wheels.
)
# The downside of `--no-build-isolation` is that pip will not download build
# dependencies. The test script will have to also handle that.


@pytest.fixture
def venv_python(tmp_path):
    run([*VIRTUALENV, str(tmp_path / ".venv")])
    possible_path = (str(p.parent) for p in tmp_path.glob(".venv/*/python*"))
    return shutil.which("python", path=os.pathsep.join(possible_path))


@pytest.fixture(autouse=True)
def _prepare(tmp_path, venv_python, monkeypatch, request):
    download_path = os.getenv("DOWNLOAD_PATH", str(tmp_path))
    os.makedirs(download_path, exist_ok=True)

    # Environment vars used for building some of the packages
    monkeypatch.setenv("USE_MYPYC", "1")

    def _debug_info():
        # Let's provide the maximum amount of information possible in the case
        # it is necessary to debug the tests directly from the CI logs.
        print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
        print("Temporary directory:")
        map(print, tmp_path.glob("*"))
        print("Virtual environment:")
        run([venv_python, "-m", "pip", "freeze"])

    request.addfinalizer(_debug_info)


ALREADY_LOADED = ("pytest", "mypy")  # loaded by pytest/pytest-enabler


@pytest.mark.parametrize('package, version', EXAMPLES)
@pytest.mark.uses_network
def test_install_sdist(package, version, tmp_path, venv_python, setuptools_wheel):
    venv_pip = (venv_python, "-m", "pip")
    sdist = retrieve_sdist(package, version, tmp_path)
    deps = build_deps(package, sdist)
    if deps:
        print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
        print("Dependencies:", deps)
        run([*venv_pip, "install", *deps])

    # Use a virtualenv to simulate PEP 517 isolation
    # but install fresh setuptools wheel to ensure the version under development
    run([*venv_pip, "install", "-I", setuptools_wheel])
    run([*venv_pip, "install", *INSTALL_OPTIONS, sdist])

    # Execute a simple script to make sure the package was installed correctly
    script = f"import {package}; print(getattr({package}, '__version__', 0))"
    run([venv_python, "-c", script])


# ---- Helper Functions ----


def retrieve_sdist(package, version, tmp_path):
    """Either use cached sdist file or download it from PyPI"""
    # `pip download` cannot be used due to
    # https://github.com/pypa/pip/issues/1884
    # https://discuss.python.org/t/pep-625-file-name-of-a-source-distribution/4686
    # We have to find the correct distribution file and download it
    download_path = os.getenv("DOWNLOAD_PATH", str(tmp_path))
    dist = retrieve_pypi_sdist_metadata(package, version)

    # Remove old files to prevent cache to grow indefinitely
    for file in glob(os.path.join(download_path, f"{package}*")):
        if dist["filename"] != file:
            os.unlink(file)

    dist_file = os.path.join(download_path, dist["filename"])
    if not os.path.exists(dist_file):
        download(dist["url"], dist_file, dist["md5_digest"])
    return dist_file


def retrieve_pypi_sdist_metadata(package, version):
    # https://warehouse.pypa.io/api-reference/json.html
    id_ = package if version is LATEST else f"{package}/{version}"
    with urlopen(f"https://pypi.org/pypi/{id_}/json") as f:
        metadata = json.load(f)

    if metadata["info"]["yanked"]:
        raise ValueError(f"Release for {package} {version} was yanked")

    version = metadata["info"]["version"]
    release = metadata["releases"][version] if version is LATEST else metadata["urls"]
    (sdist,) = filter(lambda d: d["packagetype"] == "sdist", release)
    return sdist


def download(url, dest, md5_digest):
    with urlopen(url) as f:
        data = f.read()

    assert md5(data).hexdigest() == md5_digest

    with open(dest, "wb") as f:
        f.write(data)

    assert os.path.exists(dest)


def build_deps(package, sdist_file):
    """Find out what are the build dependencies for a package.

    "Manually" install them, since pip will not install build
    deps with `--no-build-isolation`.
    """
    import tomli as toml

    # delay importing, since pytest discovery phase may hit this file from a
    # testenv without tomli

    archive = Archive(sdist_file)
    info = toml.loads(_read_pyproject(archive))
    deps = info.get("build-system", {}).get("requires", [])
    deps += EXTRA_BUILD_DEPS.get(package, [])
    # Remove setuptools from requirements (and deduplicate)
    requirements = {Requirement(d).name: d for d in deps}
    return [v for k, v in requirements.items() if k != "setuptools"]


def _read_pyproject(archive):
    contents = (
        archive.get_content(member)
        for member in archive
        if os.path.basename(archive.get_name(member)) == "pyproject.toml"
    )
    return next(contents, "")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/mod_with_constant.py0000644000175100001730000000002614467657412023130 0ustar00runnerdockervalue = 'three, sir!'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/namespaces.py0000644000175100001730000000400614467657412021526 0ustar00runnerdockerimport textwrap


def build_namespace_package(tmpdir, name):
    src_dir = tmpdir / name
    src_dir.mkdir()
    setup_py = src_dir / 'setup.py'
    namespace, sep, rest = name.partition('.')
    script = textwrap.dedent(
        """
        import setuptools
        setuptools.setup(
            name={name!r},
            version="1.0",
            namespace_packages=[{namespace!r}],
            packages=[{namespace!r}],
        )
        """
    ).format(**locals())
    setup_py.write_text(script, encoding='utf-8')
    ns_pkg_dir = src_dir / namespace
    ns_pkg_dir.mkdir()
    pkg_init = ns_pkg_dir / '__init__.py'
    tmpl = '__import__("pkg_resources").declare_namespace({namespace!r})'
    decl = tmpl.format(**locals())
    pkg_init.write_text(decl, encoding='utf-8')
    pkg_mod = ns_pkg_dir / (rest + '.py')
    some_functionality = 'name = {rest!r}'.format(**locals())
    pkg_mod.write_text(some_functionality, encoding='utf-8')
    return src_dir


def build_pep420_namespace_package(tmpdir, name):
    src_dir = tmpdir / name
    src_dir.mkdir()
    pyproject = src_dir / "pyproject.toml"
    namespace, sep, rest = name.rpartition(".")
    script = f"""\
        [build-system]
        requires = ["setuptools"]
        build-backend = "setuptools.build_meta"

        [project]
        name = "{name}"
        version = "3.14159"
        """
    pyproject.write_text(textwrap.dedent(script), encoding='utf-8')
    ns_pkg_dir = src_dir / namespace.replace(".", "/")
    ns_pkg_dir.mkdir(parents=True)
    pkg_mod = ns_pkg_dir / (rest + ".py")
    some_functionality = f"name = {rest!r}"
    pkg_mod.write_text(some_functionality, encoding='utf-8')
    return src_dir


def make_site_dir(target):
    """
    Add a sitecustomize.py module in target to cause
    target to be added to site dirs such that .pth files
    are processed there.
    """
    sc = target / 'sitecustomize.py'
    target_str = str(target)
    tmpl = '__import__("site").addsitedir({target_str!r})'
    sc.write_text(tmpl.format(**locals()), encoding='utf-8')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/script-with-bom.py0000644000175100001730000000002514467657412022434 0ustar00runnerdockerresult = 'passed'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/server.py0000644000175100001730000000456214467657412020724 0ustar00runnerdocker"""Basic http server for tests to simulate PyPI or custom indexes
"""

import os
import time
import threading
import http.server
import urllib.parse
import urllib.request


class IndexServer(http.server.HTTPServer):
    """Basic single-threaded http server simulating a package index

    You can use this server in unittest like this::
        s = IndexServer()
        s.start()
        index_url = s.base_url() + 'mytestindex'
        # do some test requests to the index
        # The index files should be located in setuptools/tests/indexes
        s.stop()
    """

    def __init__(
        self,
        server_address=('', 0),
        RequestHandlerClass=http.server.SimpleHTTPRequestHandler,
    ):
        http.server.HTTPServer.__init__(self, server_address, RequestHandlerClass)
        self._run = True

    def start(self):
        self.thread = threading.Thread(target=self.serve_forever)
        self.thread.start()

    def stop(self):
        "Stop the server"

        # Let the server finish the last request and wait for a new one.
        time.sleep(0.1)

        self.shutdown()
        self.thread.join()
        self.socket.close()

    def base_url(self):
        port = self.server_port
        return 'http://127.0.0.1:%s/setuptools/tests/indexes/' % port


class RequestRecorder(http.server.BaseHTTPRequestHandler):
    def do_GET(self):
        requests = vars(self.server).setdefault('requests', [])
        requests.append(self)
        self.send_response(200, 'OK')


class MockServer(http.server.HTTPServer, threading.Thread):
    """
    A simple HTTP Server that records the requests made to it.
    """

    def __init__(self, server_address=('', 0), RequestHandlerClass=RequestRecorder):
        http.server.HTTPServer.__init__(self, server_address, RequestHandlerClass)
        threading.Thread.__init__(self)
        self.daemon = True
        self.requests = []

    def run(self):
        self.serve_forever()

    @property
    def netloc(self):
        return 'localhost:%s' % self.server_port

    @property
    def url(self):
        return 'http://%s/' % self.netloc


def path_to_url(path, authority=None):
    """Convert a path to a file: URL."""
    path = os.path.normpath(os.path.abspath(path))
    base = 'file:'
    if authority is not None:
        base += '//' + authority
    url = urllib.parse.urljoin(base, urllib.request.pathname2url(path))
    return url
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_archive_util.py0000644000175100001730000000153614467657412023131 0ustar00runnerdocker# coding: utf-8

import tarfile
import io

import pytest

from setuptools import archive_util


@pytest.fixture
def tarfile_with_unicode(tmpdir):
    """
    Create a tarfile containing only a file whose name is
    a zero byte file called testimäge.png.
    """
    tarobj = io.BytesIO()

    with tarfile.open(fileobj=tarobj, mode="w:gz") as tgz:
        data = b""

        filename = "testimäge.png"

        t = tarfile.TarInfo(filename)
        t.size = len(data)

        tgz.addfile(t, io.BytesIO(data))

    target = tmpdir / 'unicode-pkg-1.0.tar.gz'
    with open(str(target), mode='wb') as tf:
        tf.write(tarobj.getvalue())
    return str(target)


@pytest.mark.xfail(reason="#710 and #712")
def test_unicode_files(tarfile_with_unicode, tmpdir):
    target = tmpdir / 'out'
    archive_util.unpack_archive(tarfile_with_unicode, str(target))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_bdist_deprecations.py0000644000175100001730000000126114467657412024313 0ustar00runnerdocker"""develop tests
"""
import sys
from unittest import mock

import pytest

from setuptools.dist import Distribution
from setuptools import SetuptoolsDeprecationWarning


@pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
@mock.patch('distutils.command.bdist_rpm.bdist_rpm')
def test_bdist_rpm_warning(distutils_cmd, tmpdir_cwd):
    dist = Distribution(
        dict(
            script_name='setup.py',
            script_args=['bdist_rpm'],
            name='foo',
            py_modules=['hi'],
        )
    )
    dist.parse_command_line()
    with pytest.warns(SetuptoolsDeprecationWarning):
        dist.run_commands()

    distutils_cmd.run.assert_called_once()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_bdist_egg.py0000644000175100001730000000346414467657412022404 0ustar00runnerdocker"""develop tests
"""
import os
import re
import zipfile

import pytest

from setuptools.dist import Distribution

from . import contexts

SETUP_PY = """\
from setuptools import setup

setup(py_modules=['hi'])
"""


@pytest.fixture(scope='function')
def setup_context(tmpdir):
    with (tmpdir / 'setup.py').open('w') as f:
        f.write(SETUP_PY)
    with (tmpdir / 'hi.py').open('w') as f:
        f.write('1\n')
    with tmpdir.as_cwd():
        yield tmpdir


class Test:
    def test_bdist_egg(self, setup_context, user_override):
        dist = Distribution(
            dict(
                script_name='setup.py',
                script_args=['bdist_egg'],
                name='foo',
                py_modules=['hi'],
            )
        )
        os.makedirs(os.path.join('build', 'src'))
        with contexts.quiet():
            dist.parse_command_line()
            dist.run_commands()

        # let's see if we got our egg link at the right place
        [content] = os.listdir('dist')
        assert re.match(r'foo-0.0.0-py[23].\d+.egg$', content)

    @pytest.mark.xfail(
        os.environ.get('PYTHONDONTWRITEBYTECODE'),
        reason="Byte code disabled",
    )
    def test_exclude_source_files(self, setup_context, user_override):
        dist = Distribution(
            dict(
                script_name='setup.py',
                script_args=['bdist_egg', '--exclude-source-files'],
                py_modules=['hi'],
            )
        )
        with contexts.quiet():
            dist.parse_command_line()
            dist.run_commands()
        [dist_name] = os.listdir('dist')
        dist_filename = os.path.join('dist', dist_name)
        zip = zipfile.ZipFile(dist_filename)
        names = list(zi.filename for zi in zip.filelist)
        assert 'hi.pyc' in names
        assert 'hi.py' not in names
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_build.py0000644000175100001730000000345014467657412021547 0ustar00runnerdockerfrom contextlib import contextmanager
from setuptools import Command, SetuptoolsDeprecationWarning
from setuptools.dist import Distribution
from setuptools.command.build import build
from distutils.command.build import build as distutils_build

import pytest


def test_distribution_gives_setuptools_build_obj(tmpdir_cwd):
    """
    Check that the setuptools Distribution uses the
    setuptools specific build object.
    """

    dist = Distribution(
        dict(
            script_name='setup.py',
            script_args=['build'],
            packages=[],
            package_data={'': ['path/*']},
        )
    )
    assert isinstance(dist.get_command_obj("build"), build)


@contextmanager
def _restore_sub_commands():
    orig = distutils_build.sub_commands[:]
    try:
        yield
    finally:
        distutils_build.sub_commands = orig


class Subcommand(Command):
    """Dummy command to be used in tests"""

    def initialize_options(self):
        pass

    def finalize_options(self):
        pass

    def run(self):
        raise NotImplementedError("just to check if the command runs")


@_restore_sub_commands()
def test_subcommand_in_distutils(tmpdir_cwd):
    """
    Ensure that sub commands registered in ``distutils`` run,
    after instructing the users to migrate to ``setuptools``.
    """
    dist = Distribution(
        dict(
            packages=[],
            cmdclass={'subcommand': Subcommand},
        )
    )
    distutils_build.sub_commands.append(('subcommand', None))

    warning_msg = "please use .setuptools.command.build."
    with pytest.warns(SetuptoolsDeprecationWarning, match=warning_msg):
        # For backward compatibility, the subcommand should run anyway:
        with pytest.raises(NotImplementedError, match="the command runs"):
            dist.run_command("build")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_build_clib.py0000644000175100001730000000606214467657412022542 0ustar00runnerdockerfrom unittest import mock

import pytest

import random
from distutils.errors import DistutilsSetupError
from setuptools.command.build_clib import build_clib
from setuptools.dist import Distribution


class TestBuildCLib:
    @mock.patch('setuptools.command.build_clib.newer_pairwise_group')
    def test_build_libraries(self, mock_newer):
        dist = Distribution()
        cmd = build_clib(dist)

        # this will be a long section, just making sure all
        # exceptions are properly raised
        libs = [('example', {'sources': 'broken.c'})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        obj_deps = 'some_string'
        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        obj_deps = {'': ''}
        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        obj_deps = {'source.c': ''}
        libs = [('example', {'sources': ['source.c'], 'obj_deps': obj_deps})]
        with pytest.raises(DistutilsSetupError):
            cmd.build_libraries(libs)

        # with that out of the way, let's see if the crude dependency
        # system works
        cmd.compiler = mock.MagicMock(spec=cmd.compiler)
        mock_newer.return_value = ([], [])

        obj_deps = {'': ('global.h',), 'example.c': ('example.h',)}
        libs = [('example', {'sources': ['example.c'], 'obj_deps': obj_deps})]

        cmd.build_libraries(libs)
        assert [['example.c', 'global.h', 'example.h']] in mock_newer.call_args[0]
        assert not cmd.compiler.compile.called
        assert cmd.compiler.create_static_lib.call_count == 1

        # reset the call numbers so we can test again
        cmd.compiler.reset_mock()

        mock_newer.return_value = ''  # anything as long as it's not ([],[])
        cmd.build_libraries(libs)
        assert cmd.compiler.compile.call_count == 1
        assert cmd.compiler.create_static_lib.call_count == 1

    @mock.patch('setuptools.command.build_clib.newer_pairwise_group')
    def test_build_libraries_reproducible(self, mock_newer):
        dist = Distribution()
        cmd = build_clib(dist)

        # with that out of the way, let's see if the crude dependency
        # system works
        cmd.compiler = mock.MagicMock(spec=cmd.compiler)
        mock_newer.return_value = ([], [])

        original_sources = ['a-example.c', 'example.c']
        sources = original_sources

        obj_deps = {'': ('global.h',), 'example.c': ('example.h',)}
        libs = [('example', {'sources': sources, 'obj_deps': obj_deps})]

        cmd.build_libraries(libs)
        computed_call_args = mock_newer.call_args[0]

        while sources == original_sources:
            sources = random.sample(original_sources, len(original_sources))
        libs = [('example', {'sources': sources, 'obj_deps': obj_deps})]

        cmd.build_libraries(libs)
        assert computed_call_args == mock_newer.call_args[0]
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_build_ext.py0000644000175100001730000002350314467657412022430 0ustar00runnerdockerimport os
import sys
import distutils.command.build_ext as orig
from distutils.sysconfig import get_config_var
from importlib.util import cache_from_source as _compiled_file_name

from jaraco import path

from setuptools.command.build_ext import build_ext, get_abi3_suffix
from setuptools.dist import Distribution
from setuptools.extension import Extension
from setuptools.errors import CompileError

from . import environment
from .textwrap import DALS

import pytest


IS_PYPY = '__pypy__' in sys.builtin_module_names


class TestBuildExt:
    def test_get_ext_filename(self):
        """
        Setuptools needs to give back the same
        result as distutils, even if the fullname
        is not in ext_map.
        """
        dist = Distribution()
        cmd = build_ext(dist)
        cmd.ext_map['foo/bar'] = ''
        res = cmd.get_ext_filename('foo')
        wanted = orig.build_ext.get_ext_filename(cmd, 'foo')
        assert res == wanted

    def test_abi3_filename(self):
        """
        Filename needs to be loadable by several versions
        of Python 3 if 'is_abi3' is truthy on Extension()
        """
        print(get_abi3_suffix())

        extension = Extension('spam.eggs', ['eggs.c'], py_limited_api=True)
        dist = Distribution(dict(ext_modules=[extension]))
        cmd = build_ext(dist)
        cmd.finalize_options()
        assert 'spam.eggs' in cmd.ext_map
        res = cmd.get_ext_filename('spam.eggs')

        if not get_abi3_suffix():
            assert res.endswith(get_config_var('EXT_SUFFIX'))
        elif sys.platform == 'win32':
            assert res.endswith('eggs.pyd')
        else:
            assert 'abi3' in res

    def test_ext_suffix_override(self):
        """
        SETUPTOOLS_EXT_SUFFIX variable always overrides
        default extension options.
        """
        dist = Distribution()
        cmd = build_ext(dist)
        cmd.ext_map['for_abi3'] = ext = Extension(
            'for_abi3',
            ['s.c'],
            # Override shouldn't affect abi3 modules
            py_limited_api=True,
        )
        # Mock value needed to pass tests
        ext._links_to_dynamic = False

        if not IS_PYPY:
            expect = cmd.get_ext_filename('for_abi3')
        else:
            # PyPy builds do not use ABI3 tag, so they will
            # also get the overridden suffix.
            expect = 'for_abi3.test-suffix'

        try:
            os.environ['SETUPTOOLS_EXT_SUFFIX'] = '.test-suffix'
            res = cmd.get_ext_filename('normal')
            assert 'normal.test-suffix' == res
            res = cmd.get_ext_filename('for_abi3')
            assert expect == res
        finally:
            del os.environ['SETUPTOOLS_EXT_SUFFIX']

    def dist_with_example(self):
        files = {
            "src": {"mypkg": {"subpkg": {"ext2.c": ""}}},
            "c-extensions": {"ext1": {"main.c": ""}},
        }

        ext1 = Extension("mypkg.ext1", ["c-extensions/ext1/main.c"])
        ext2 = Extension("mypkg.subpkg.ext2", ["src/mypkg/subpkg/ext2.c"])
        ext3 = Extension("ext3", ["c-extension/ext3.c"])

        path.build(files)
        dist = Distribution(
            {
                "script_name": "%test%",
                "ext_modules": [ext1, ext2, ext3],
                "package_dir": {"": "src"},
            }
        )
        return dist

    def test_get_outputs(self, tmpdir_cwd, monkeypatch):
        monkeypatch.setenv('SETUPTOOLS_EXT_SUFFIX', '.mp3')  # make test OS-independent
        monkeypatch.setattr('setuptools.command.build_ext.use_stubs', False)
        dist = self.dist_with_example()

        # Regular build: get_outputs not empty, but get_output_mappings is empty
        build_ext = dist.get_command_obj("build_ext")
        build_ext.editable_mode = False
        build_ext.ensure_finalized()
        build_lib = build_ext.build_lib.replace(os.sep, "/")
        outputs = [x.replace(os.sep, "/") for x in build_ext.get_outputs()]
        assert outputs == [
            f"{build_lib}/ext3.mp3",
            f"{build_lib}/mypkg/ext1.mp3",
            f"{build_lib}/mypkg/subpkg/ext2.mp3",
        ]
        assert build_ext.get_output_mapping() == {}

        # Editable build: get_output_mappings should contain everything in get_outputs
        dist.reinitialize_command("build_ext")
        build_ext.editable_mode = True
        build_ext.ensure_finalized()
        mapping = {
            k.replace(os.sep, "/"): v.replace(os.sep, "/")
            for k, v in build_ext.get_output_mapping().items()
        }
        assert mapping == {
            f"{build_lib}/ext3.mp3": "src/ext3.mp3",
            f"{build_lib}/mypkg/ext1.mp3": "src/mypkg/ext1.mp3",
            f"{build_lib}/mypkg/subpkg/ext2.mp3": "src/mypkg/subpkg/ext2.mp3",
        }

    def test_get_output_mapping_with_stub(self, tmpdir_cwd, monkeypatch):
        monkeypatch.setenv('SETUPTOOLS_EXT_SUFFIX', '.mp3')  # make test OS-independent
        monkeypatch.setattr('setuptools.command.build_ext.use_stubs', True)
        dist = self.dist_with_example()

        # Editable build should create compiled stubs (.pyc files only, no .py)
        build_ext = dist.get_command_obj("build_ext")
        build_ext.editable_mode = True
        build_ext.ensure_finalized()
        for ext in build_ext.extensions:
            monkeypatch.setattr(ext, "_needs_stub", True)

        build_lib = build_ext.build_lib.replace(os.sep, "/")
        mapping = {
            k.replace(os.sep, "/"): v.replace(os.sep, "/")
            for k, v in build_ext.get_output_mapping().items()
        }

        def C(file):
            """Make it possible to do comparisons and tests in a OS-independent way"""
            return _compiled_file_name(file).replace(os.sep, "/")

        assert mapping == {
            C(f"{build_lib}/ext3.py"): C("src/ext3.py"),
            f"{build_lib}/ext3.mp3": "src/ext3.mp3",
            C(f"{build_lib}/mypkg/ext1.py"): C("src/mypkg/ext1.py"),
            f"{build_lib}/mypkg/ext1.mp3": "src/mypkg/ext1.mp3",
            C(f"{build_lib}/mypkg/subpkg/ext2.py"): C("src/mypkg/subpkg/ext2.py"),
            f"{build_lib}/mypkg/subpkg/ext2.mp3": "src/mypkg/subpkg/ext2.mp3",
        }

        # Ensure only the compiled stubs are present not the raw .py stub
        assert f"{build_lib}/mypkg/ext1.py" not in mapping
        assert f"{build_lib}/mypkg/subpkg/ext2.py" not in mapping

        # Visualize what the cached stub files look like
        example_stub = C(f"{build_lib}/mypkg/ext1.py")
        assert example_stub in mapping
        assert example_stub.startswith(f"{build_lib}/mypkg/__pycache__/ext1")
        assert example_stub.endswith(".pyc")


class TestBuildExtInplace:
    def get_build_ext_cmd(self, optional: bool, **opts):
        files = {
            "eggs.c": "#include missingheader.h\n",
            ".build": {"lib": {}, "tmp": {}},
        }
        path.build(files)
        extension = Extension('spam.eggs', ['eggs.c'], optional=optional)
        dist = Distribution(dict(ext_modules=[extension]))
        dist.script_name = 'setup.py'
        cmd = build_ext(dist)
        vars(cmd).update(build_lib=".build/lib", build_temp=".build/tmp", **opts)
        cmd.ensure_finalized()
        return cmd

    def get_log_messages(self, caplog, capsys):
        """
        Historically, distutils "logged" by printing to sys.std*.
        Later versions adopted the logging framework. Grab
        messages regardless of how they were captured.
        """
        std = capsys.readouterr()
        return std.out.splitlines() + std.err.splitlines() + caplog.messages

    def test_optional(self, tmpdir_cwd, caplog, capsys):
        """
        If optional extensions fail to build, setuptools should show the error
        in the logs but not fail to build
        """
        cmd = self.get_build_ext_cmd(optional=True, inplace=True)
        cmd.run()
        assert any(
            'build_ext: building extension "spam.eggs" failed'
            for msg in self.get_log_messages(caplog, capsys)
        )
        # No compile error exception should be raised

    def test_non_optional(self, tmpdir_cwd):
        # Non-optional extensions should raise an exception
        cmd = self.get_build_ext_cmd(optional=False, inplace=True)
        with pytest.raises(CompileError):
            cmd.run()


def test_build_ext_config_handling(tmpdir_cwd):
    files = {
        'setup.py': DALS(
            """
            from setuptools import Extension, setup
            setup(
                name='foo',
                version='0.0.0',
                ext_modules=[Extension('foo', ['foo.c'])],
            )
            """
        ),
        'foo.c': DALS(
            """
            #include "Python.h"

            #if PY_MAJOR_VERSION >= 3

            static struct PyModuleDef moduledef = {
                    PyModuleDef_HEAD_INIT,
                    "foo",
                    NULL,
                    0,
                    NULL,
                    NULL,
                    NULL,
                    NULL,
                    NULL
            };

            #define INITERROR return NULL

            PyMODINIT_FUNC PyInit_foo(void)

            #else

            #define INITERROR return

            void initfoo(void)

            #endif
            {
            #if PY_MAJOR_VERSION >= 3
                PyObject *module = PyModule_Create(&moduledef);
            #else
                PyObject *module = Py_InitModule("extension", NULL);
            #endif
                if (module == NULL)
                    INITERROR;
            #if PY_MAJOR_VERSION >= 3
                return module;
            #endif
            }
            """
        ),
        'setup.cfg': DALS(
            """
            [build]
            build_base = foo_build
            """
        ),
    }
    path.build(files)
    code, output = environment.run_setup_py(
        cmd=['build'],
        data_stream=(0, 2),
    )
    assert code == 0, '\nSTDOUT:\n%s\nSTDERR:\n%s' % output
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_build_meta.py0000644000175100001730000010231614467657412022556 0ustar00runnerdockerimport os
import sys
import shutil
import signal
import tarfile
import importlib
import contextlib
from concurrent import futures
import re
from zipfile import ZipFile
from pathlib import Path

import pytest
from jaraco import path

from .textwrap import DALS

SETUP_SCRIPT_STUB = "__import__('setuptools').setup()"


TIMEOUT = int(os.getenv("TIMEOUT_BACKEND_TEST", "180"))  # in seconds
IS_PYPY = '__pypy__' in sys.builtin_module_names


pytestmark = pytest.mark.skipif(
    sys.platform == "win32" and IS_PYPY,
    reason="The combination of PyPy + Windows + pytest-xdist + ProcessPoolExecutor "
    "is flaky and problematic",
)


class BuildBackendBase:
    def __init__(self, cwd='.', env={}, backend_name='setuptools.build_meta'):
        self.cwd = cwd
        self.env = env
        self.backend_name = backend_name


class BuildBackend(BuildBackendBase):
    """PEP 517 Build Backend"""

    def __init__(self, *args, **kwargs):
        super(BuildBackend, self).__init__(*args, **kwargs)
        self.pool = futures.ProcessPoolExecutor(max_workers=1)

    def __getattr__(self, name):
        """Handles arbitrary function invocations on the build backend."""

        def method(*args, **kw):
            root = os.path.abspath(self.cwd)
            caller = BuildBackendCaller(root, self.env, self.backend_name)
            pid = None
            try:
                pid = self.pool.submit(os.getpid).result(TIMEOUT)
                return self.pool.submit(caller, name, *args, **kw).result(TIMEOUT)
            except futures.TimeoutError:
                self.pool.shutdown(wait=False)  # doesn't stop already running processes
                self._kill(pid)
                pytest.xfail(f"Backend did not respond before timeout ({TIMEOUT} s)")
            except (futures.process.BrokenProcessPool, MemoryError, OSError):
                if IS_PYPY:
                    pytest.xfail("PyPy frequently fails tests with ProcessPoolExector")
                raise

        return method

    def _kill(self, pid):
        if pid is None:
            return
        with contextlib.suppress(ProcessLookupError, OSError):
            os.kill(pid, signal.SIGTERM if os.name == "nt" else signal.SIGKILL)


class BuildBackendCaller(BuildBackendBase):
    def __init__(self, *args, **kwargs):
        super(BuildBackendCaller, self).__init__(*args, **kwargs)

        (self.backend_name, _, self.backend_obj) = self.backend_name.partition(':')

    def __call__(self, name, *args, **kw):
        """Handles arbitrary function invocations on the build backend."""
        os.chdir(self.cwd)
        os.environ.update(self.env)
        mod = importlib.import_module(self.backend_name)

        if self.backend_obj:
            backend = getattr(mod, self.backend_obj)
        else:
            backend = mod

        return getattr(backend, name)(*args, **kw)


defns = [
    {  # simple setup.py script
        'setup.py': DALS(
            """
            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
                py_modules=['hello'],
                setup_requires=['six'],
            )
            """
        ),
        'hello.py': DALS(
            """
            def run():
                print('hello')
            """
        ),
    },
    {  # setup.py that relies on __name__
        'setup.py': DALS(
            """
            assert __name__ == '__main__'
            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
                py_modules=['hello'],
                setup_requires=['six'],
            )
            """
        ),
        'hello.py': DALS(
            """
            def run():
                print('hello')
            """
        ),
    },
    {  # setup.py script that runs arbitrary code
        'setup.py': DALS(
            """
            variable = True
            def function():
                return variable
            assert variable
            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
                py_modules=['hello'],
                setup_requires=['six'],
            )
            """
        ),
        'hello.py': DALS(
            """
            def run():
                print('hello')
            """
        ),
    },
    {  # setup.py script that constructs temp files to be included in the distribution
        'setup.py': DALS(
            """
            # Some packages construct files on the fly, include them in the package,
            # and immediately remove them after `setup()` (e.g. pybind11==2.9.1).
            # Therefore, we cannot use `distutils.core.run_setup(..., stop_after=...)`
            # to obtain a distribution object first, and then run the distutils
            # commands later, because these files will be removed in the meantime.

            with open('world.py', 'w') as f:
                f.write('x = 42')

            try:
                __import__('setuptools').setup(
                    name='foo',
                    version='0.0.0',
                    py_modules=['world'],
                    setup_requires=['six'],
                )
            finally:
                # Some packages will clean temporary files
                __import__('os').unlink('world.py')
            """
        ),
    },
    {  # setup.cfg only
        'setup.cfg': DALS(
            """
        [metadata]
        name = foo
        version = 0.0.0

        [options]
        py_modules=hello
        setup_requires=six
        """
        ),
        'hello.py': DALS(
            """
        def run():
            print('hello')
        """
        ),
    },
    {  # setup.cfg and setup.py
        'setup.cfg': DALS(
            """
        [metadata]
        name = foo
        version = 0.0.0

        [options]
        py_modules=hello
        setup_requires=six
        """
        ),
        'setup.py': "__import__('setuptools').setup()",
        'hello.py': DALS(
            """
        def run():
            print('hello')
        """
        ),
    },
]


class TestBuildMetaBackend:
    backend_name = 'setuptools.build_meta'

    def get_build_backend(self):
        return BuildBackend(backend_name=self.backend_name)

    @pytest.fixture(params=defns)
    def build_backend(self, tmpdir, request):
        path.build(request.param, prefix=str(tmpdir))
        with tmpdir.as_cwd():
            yield self.get_build_backend()

    def test_get_requires_for_build_wheel(self, build_backend):
        actual = build_backend.get_requires_for_build_wheel()
        expected = ['six', 'wheel']
        assert sorted(actual) == sorted(expected)

    def test_get_requires_for_build_sdist(self, build_backend):
        actual = build_backend.get_requires_for_build_sdist()
        expected = ['six']
        assert sorted(actual) == sorted(expected)

    def test_build_wheel(self, build_backend):
        dist_dir = os.path.abspath('pip-wheel')
        os.makedirs(dist_dir)
        wheel_name = build_backend.build_wheel(dist_dir)

        wheel_file = os.path.join(dist_dir, wheel_name)
        assert os.path.isfile(wheel_file)

        # Temporary files should be removed
        assert not os.path.isfile('world.py')

        with ZipFile(wheel_file) as zipfile:
            wheel_contents = set(zipfile.namelist())

        # Each one of the examples have a single module
        # that should be included in the distribution
        python_scripts = (f for f in wheel_contents if f.endswith('.py'))
        modules = [f for f in python_scripts if not f.endswith('setup.py')]
        assert len(modules) == 1

    @pytest.mark.parametrize('build_type', ('wheel', 'sdist'))
    def test_build_with_existing_file_present(self, build_type, tmpdir_cwd):
        # Building a sdist/wheel should still succeed if there's
        # already a sdist/wheel in the destination directory.
        files = {
            'setup.py': "from setuptools import setup\nsetup()",
            'VERSION': "0.0.1",
            'setup.cfg': DALS(
                """
                [metadata]
                name = foo
                version = file: VERSION
            """
            ),
            'pyproject.toml': DALS(
                """
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"
            """
            ),
        }

        path.build(files)

        dist_dir = os.path.abspath('preexisting-' + build_type)

        build_backend = self.get_build_backend()
        build_method = getattr(build_backend, 'build_' + build_type)

        # Build a first sdist/wheel.
        # Note: this also check the destination directory is
        # successfully created if it does not exist already.
        first_result = build_method(dist_dir)

        # Change version.
        with open("VERSION", "wt") as version_file:
            version_file.write("0.0.2")

        # Build a *second* sdist/wheel.
        second_result = build_method(dist_dir)

        assert os.path.isfile(os.path.join(dist_dir, first_result))
        assert first_result != second_result

        # And if rebuilding the exact same sdist/wheel?
        open(os.path.join(dist_dir, second_result), 'w').close()
        third_result = build_method(dist_dir)
        assert third_result == second_result
        assert os.path.getsize(os.path.join(dist_dir, third_result)) > 0

    @pytest.mark.parametrize("setup_script", [None, SETUP_SCRIPT_STUB])
    def test_build_with_pyproject_config(self, tmpdir, setup_script):
        files = {
            'pyproject.toml': DALS(
                """
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"

                [project]
                name = "foo"
                license = {text = "MIT"}
                description = "This is a Python package"
                dynamic = ["version", "readme"]
                classifiers = [
                    "Development Status :: 5 - Production/Stable",
                    "Intended Audience :: Developers"
                ]
                urls = {Homepage = "http://github.com"}
                dependencies = [
                    "appdirs",
                ]

                [project.optional-dependencies]
                all = [
                    "tomli>=1",
                    "pyscaffold>=4,<5",
                    'importlib; python_version == "2.6"',
                ]

                [project.scripts]
                foo = "foo.cli:main"

                [tool.setuptools]
                zip-safe = false
                package-dir = {"" = "src"}
                packages = {find = {where = ["src"]}}
                license-files = ["LICENSE*"]

                [tool.setuptools.dynamic]
                version = {attr = "foo.__version__"}
                readme = {file = "README.rst"}

                [tool.distutils.sdist]
                formats = "gztar"

                [tool.distutils.bdist_wheel]
                universal = true
                """
            ),
            "MANIFEST.in": DALS(
                """
                global-include *.py *.txt
                global-exclude *.py[cod]
                """
            ),
            "README.rst": "This is a ``README``",
            "LICENSE.txt": "---- placeholder MIT license ----",
            "src": {
                "foo": {
                    "__init__.py": "__version__ = '0.1'",
                    "cli.py": "def main(): print('hello world')",
                    "data.txt": "def main(): print('hello world')",
                }
            },
        }
        if setup_script:
            files["setup.py"] = setup_script

        build_backend = self.get_build_backend()
        with tmpdir.as_cwd():
            path.build(files)
            sdist_path = build_backend.build_sdist("temp")
            wheel_file = build_backend.build_wheel("temp")

        with tarfile.open(os.path.join(tmpdir, "temp", sdist_path)) as tar:
            sdist_contents = set(tar.getnames())

        with ZipFile(os.path.join(tmpdir, "temp", wheel_file)) as zipfile:
            wheel_contents = set(zipfile.namelist())
            metadata = str(zipfile.read("foo-0.1.dist-info/METADATA"), "utf-8")
            license = str(zipfile.read("foo-0.1.dist-info/LICENSE.txt"), "utf-8")
            epoints = str(zipfile.read("foo-0.1.dist-info/entry_points.txt"), "utf-8")

        assert sdist_contents - {"foo-0.1/setup.py"} == {
            'foo-0.1',
            'foo-0.1/LICENSE.txt',
            'foo-0.1/MANIFEST.in',
            'foo-0.1/PKG-INFO',
            'foo-0.1/README.rst',
            'foo-0.1/pyproject.toml',
            'foo-0.1/setup.cfg',
            'foo-0.1/src',
            'foo-0.1/src/foo',
            'foo-0.1/src/foo/__init__.py',
            'foo-0.1/src/foo/cli.py',
            'foo-0.1/src/foo/data.txt',
            'foo-0.1/src/foo.egg-info',
            'foo-0.1/src/foo.egg-info/PKG-INFO',
            'foo-0.1/src/foo.egg-info/SOURCES.txt',
            'foo-0.1/src/foo.egg-info/dependency_links.txt',
            'foo-0.1/src/foo.egg-info/entry_points.txt',
            'foo-0.1/src/foo.egg-info/requires.txt',
            'foo-0.1/src/foo.egg-info/top_level.txt',
            'foo-0.1/src/foo.egg-info/not-zip-safe',
        }
        assert wheel_contents == {
            "foo/__init__.py",
            "foo/cli.py",
            "foo/data.txt",  # include_package_data defaults to True
            "foo-0.1.dist-info/LICENSE.txt",
            "foo-0.1.dist-info/METADATA",
            "foo-0.1.dist-info/WHEEL",
            "foo-0.1.dist-info/entry_points.txt",
            "foo-0.1.dist-info/top_level.txt",
            "foo-0.1.dist-info/RECORD",
        }
        assert license == "---- placeholder MIT license ----"

        metadata = metadata.replace("(", "").replace(")", "")
        # ^-- compatibility hack for pypa/wheel#552

        for line in (
            "Summary: This is a Python package",
            "License: MIT",
            "Classifier: Intended Audience :: Developers",
            "Requires-Dist: appdirs",
            "Requires-Dist: tomli >=1 ; extra == 'all'",
            "Requires-Dist: importlib ; python_version == \"2.6\" and extra == 'all'",
        ):
            assert line in metadata

        assert metadata.strip().endswith("This is a ``README``")
        assert epoints.strip() == "[console_scripts]\nfoo = foo.cli:main"

    def test_static_metadata_in_pyproject_config(self, tmpdir):
        # Make sure static metadata in pyproject.toml is not overwritten by setup.py
        # as required by PEP 621
        files = {
            'pyproject.toml': DALS(
                """
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"

                [project]
                name = "foo"
                description = "This is a Python package"
                version = "42"
                dependencies = ["six"]
                """
            ),
            'hello.py': DALS(
                """
                def run():
                    print('hello')
                """
            ),
            'setup.py': DALS(
                """
                __import__('setuptools').setup(
                    name='bar',
                    version='13',
                )
                """
            ),
        }
        build_backend = self.get_build_backend()
        with tmpdir.as_cwd():
            path.build(files)
            sdist_path = build_backend.build_sdist("temp")
            wheel_file = build_backend.build_wheel("temp")

        assert (tmpdir / "temp/foo-42.tar.gz").exists()
        assert (tmpdir / "temp/foo-42-py3-none-any.whl").exists()
        assert not (tmpdir / "temp/bar-13.tar.gz").exists()
        assert not (tmpdir / "temp/bar-42.tar.gz").exists()
        assert not (tmpdir / "temp/foo-13.tar.gz").exists()
        assert not (tmpdir / "temp/bar-13-py3-none-any.whl").exists()
        assert not (tmpdir / "temp/bar-42-py3-none-any.whl").exists()
        assert not (tmpdir / "temp/foo-13-py3-none-any.whl").exists()

        with tarfile.open(os.path.join(tmpdir, "temp", sdist_path)) as tar:
            pkg_info = str(tar.extractfile('foo-42/PKG-INFO').read(), "utf-8")
            members = tar.getnames()
            assert "bar-13/PKG-INFO" not in members

        with ZipFile(os.path.join(tmpdir, "temp", wheel_file)) as zipfile:
            metadata = str(zipfile.read("foo-42.dist-info/METADATA"), "utf-8")
            members = zipfile.namelist()
            assert "bar-13.dist-info/METADATA" not in members

        for file in pkg_info, metadata:
            for line in ("Name: foo", "Version: 42"):
                assert line in file
            for line in ("Name: bar", "Version: 13"):
                assert line not in file

    def test_build_sdist(self, build_backend):
        dist_dir = os.path.abspath('pip-sdist')
        os.makedirs(dist_dir)
        sdist_name = build_backend.build_sdist(dist_dir)

        assert os.path.isfile(os.path.join(dist_dir, sdist_name))

    def test_prepare_metadata_for_build_wheel(self, build_backend):
        dist_dir = os.path.abspath('pip-dist-info')
        os.makedirs(dist_dir)

        dist_info = build_backend.prepare_metadata_for_build_wheel(dist_dir)

        assert os.path.isfile(os.path.join(dist_dir, dist_info, 'METADATA'))

    def test_prepare_metadata_inplace(self, build_backend):
        """
        Some users might pass metadata_directory pre-populated with `.tox` or `.venv`.
        See issue #3523.
        """
        for pre_existing in [
            ".tox/python/lib/python3.10/site-packages/attrs-22.1.0.dist-info",
            ".tox/python/lib/python3.10/site-packages/autocommand-2.2.1.dist-info",
            ".nox/python/lib/python3.10/site-packages/build-0.8.0.dist-info",
            ".venv/python3.10/site-packages/click-8.1.3.dist-info",
            "venv/python3.10/site-packages/distlib-0.3.5.dist-info",
            "env/python3.10/site-packages/docutils-0.19.dist-info",
        ]:
            os.makedirs(pre_existing, exist_ok=True)
        dist_info = build_backend.prepare_metadata_for_build_wheel(".")
        assert os.path.isfile(os.path.join(dist_info, 'METADATA'))

    def test_build_sdist_explicit_dist(self, build_backend):
        # explicitly specifying the dist folder should work
        # the folder sdist_directory and the ``--dist-dir`` can be the same
        dist_dir = os.path.abspath('dist')
        sdist_name = build_backend.build_sdist(dist_dir)
        assert os.path.isfile(os.path.join(dist_dir, sdist_name))

    def test_build_sdist_version_change(self, build_backend):
        sdist_into_directory = os.path.abspath("out_sdist")
        os.makedirs(sdist_into_directory)

        sdist_name = build_backend.build_sdist(sdist_into_directory)
        assert os.path.isfile(os.path.join(sdist_into_directory, sdist_name))

        # if the setup.py changes subsequent call of the build meta
        # should still succeed, given the
        # sdist_directory the frontend specifies is empty
        setup_loc = os.path.abspath("setup.py")
        if not os.path.exists(setup_loc):
            setup_loc = os.path.abspath("setup.cfg")

        with open(setup_loc, 'rt') as file_handler:
            content = file_handler.read()
        with open(setup_loc, 'wt') as file_handler:
            file_handler.write(content.replace("version='0.0.0'", "version='0.0.1'"))

        shutil.rmtree(sdist_into_directory)
        os.makedirs(sdist_into_directory)

        sdist_name = build_backend.build_sdist("out_sdist")
        assert os.path.isfile(os.path.join(os.path.abspath("out_sdist"), sdist_name))

    def test_build_sdist_pyproject_toml_exists(self, tmpdir_cwd):
        files = {
            'setup.py': DALS(
                """
                __import__('setuptools').setup(
                    name='foo',
                    version='0.0.0',
                    py_modules=['hello']
                )"""
            ),
            'hello.py': '',
            'pyproject.toml': DALS(
                """
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"
                """
            ),
        }
        path.build(files)
        build_backend = self.get_build_backend()
        targz_path = build_backend.build_sdist("temp")
        with tarfile.open(os.path.join("temp", targz_path)) as tar:
            assert any('pyproject.toml' in name for name in tar.getnames())

    def test_build_sdist_setup_py_exists(self, tmpdir_cwd):
        # If build_sdist is called from a script other than setup.py,
        # ensure setup.py is included
        path.build(defns[0])

        build_backend = self.get_build_backend()
        targz_path = build_backend.build_sdist("temp")
        with tarfile.open(os.path.join("temp", targz_path)) as tar:
            assert any('setup.py' in name for name in tar.getnames())

    def test_build_sdist_setup_py_manifest_excluded(self, tmpdir_cwd):
        # Ensure that MANIFEST.in can exclude setup.py
        files = {
            'setup.py': DALS(
                """
        __import__('setuptools').setup(
            name='foo',
            version='0.0.0',
            py_modules=['hello']
        )"""
            ),
            'hello.py': '',
            'MANIFEST.in': DALS(
                """
        exclude setup.py
        """
            ),
        }

        path.build(files)

        build_backend = self.get_build_backend()
        targz_path = build_backend.build_sdist("temp")
        with tarfile.open(os.path.join("temp", targz_path)) as tar:
            assert not any('setup.py' in name for name in tar.getnames())

    def test_build_sdist_builds_targz_even_if_zip_indicated(self, tmpdir_cwd):
        files = {
            'setup.py': DALS(
                """
                __import__('setuptools').setup(
                    name='foo',
                    version='0.0.0',
                    py_modules=['hello']
                )"""
            ),
            'hello.py': '',
            'setup.cfg': DALS(
                """
                [sdist]
                formats=zip
                """
            ),
        }

        path.build(files)

        build_backend = self.get_build_backend()
        build_backend.build_sdist("temp")

    _relative_path_import_files = {
        'setup.py': DALS(
            """
            __import__('setuptools').setup(
                name='foo',
                version=__import__('hello').__version__,
                py_modules=['hello']
            )"""
        ),
        'hello.py': '__version__ = "0.0.0"',
        'setup.cfg': DALS(
            """
            [sdist]
            formats=zip
            """
        ),
    }

    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
        path.build(self._relative_path_import_files)
        build_backend = self.get_build_backend()
        with pytest.raises(ImportError, match="^No module named 'hello'$"):
            build_backend.build_sdist("temp")

    _simple_pyproject_example = {
        "pyproject.toml": DALS(
            """
            [project]
            name = "proj"
            version = "42"
            """
        ),
        "src": {"proj": {"__init__.py": ""}},
    }

    def _assert_link_tree(self, parent_dir):
        """All files in the directory should be either links or hard links"""
        files = list(Path(parent_dir).glob("**/*"))
        assert files  # Should not be empty
        for file in files:
            assert file.is_symlink() or os.stat(file).st_nlink > 0

    @pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
    # Since the backend is running via a process pool, in some operating systems
    # we may have problems to make assertions based on warnings/stdout/stderr...
    # So the best is to ignore them for the time being.
    def test_editable_with_global_option_still_works(self, tmpdir_cwd):
        """The usage of --global-option is now discouraged in favour of --build-option.
        This is required to make more sense of the provided scape hatch and align with
        previous pip behaviour. See pypa/setuptools#1928.
        """
        path.build({**self._simple_pyproject_example, '_meta': {}})
        build_backend = self.get_build_backend()
        assert not Path("build").exists()

        cfg = {"--global-option": ["--mode", "strict"]}
        build_backend.prepare_metadata_for_build_editable("_meta", cfg)
        build_backend.build_editable("temp", cfg, "_meta")

        self._assert_link_tree(next(Path("build").glob("__editable__.*")))

    def test_editable_without_config_settings(self, tmpdir_cwd):
        """
        Sanity check to ensure tests with --mode=strict are different from the ones
        without --mode.

        --mode=strict should create a local directory with a package tree.
        The directory should not get created otherwise.
        """
        path.build(self._simple_pyproject_example)
        build_backend = self.get_build_backend()
        assert not Path("build").exists()
        build_backend.build_editable("temp")
        assert not Path("build").exists()

    @pytest.mark.parametrize(
        "config_settings",
        [
            {"--build-option": ["--mode", "strict"]},
            {"editable-mode": "strict"},
        ],
    )
    def test_editable_with_config_settings(self, tmpdir_cwd, config_settings):
        path.build({**self._simple_pyproject_example, '_meta': {}})
        assert not Path("build").exists()
        build_backend = self.get_build_backend()
        build_backend.prepare_metadata_for_build_editable("_meta", config_settings)
        build_backend.build_editable("temp", config_settings, "_meta")
        self._assert_link_tree(next(Path("build").glob("__editable__.*")))

    @pytest.mark.parametrize(
        'setup_literal, requirements',
        [
            ("'foo'", ['foo']),
            ("['foo']", ['foo']),
            (r"'foo\n'", ['foo']),
            (r"'foo\n\n'", ['foo']),
            ("['foo', 'bar']", ['foo', 'bar']),
            (r"'# Has a comment line\nfoo'", ['foo']),
            (r"'foo # Has an inline comment'", ['foo']),
            (r"'foo \\\n >=3.0'", ['foo>=3.0']),
            (r"'foo\nbar'", ['foo', 'bar']),
            (r"'foo\nbar\n'", ['foo', 'bar']),
            (r"['foo\n', 'bar\n']", ['foo', 'bar']),
        ],
    )
    @pytest.mark.parametrize('use_wheel', [True, False])
    def test_setup_requires(self, setup_literal, requirements, use_wheel, tmpdir_cwd):
        files = {
            'setup.py': DALS(
                """
                from setuptools import setup

                setup(
                    name="qux",
                    version="0.0.0",
                    py_modules=["hello"],
                    setup_requires={setup_literal},
                )
            """
            ).format(setup_literal=setup_literal),
            'hello.py': DALS(
                """
            def run():
                print('hello')
            """
            ),
        }

        path.build(files)

        build_backend = self.get_build_backend()

        if use_wheel:
            base_requirements = ['wheel']
            get_requires = build_backend.get_requires_for_build_wheel
        else:
            base_requirements = []
            get_requires = build_backend.get_requires_for_build_sdist

        # Ensure that the build requirements are properly parsed
        expected = sorted(base_requirements + requirements)
        actual = get_requires()

        assert expected == sorted(actual)

    def test_setup_requires_with_auto_discovery(self, tmpdir_cwd):
        # Make sure patches introduced to retrieve setup_requires don't accidentally
        # activate auto-discovery and cause problems due to the incomplete set of
        # attributes passed to MinimalDistribution
        files = {
            'pyproject.toml': DALS(
                """
                [project]
                name = "proj"
                version = "42"
            """
            ),
            "setup.py": DALS(
                """
                __import__('setuptools').setup(
                    setup_requires=["foo"],
                    py_modules = ["hello", "world"]
                )
            """
            ),
            'hello.py': "'hello'",
            'world.py': "'world'",
        }
        path.build(files)
        build_backend = self.get_build_backend()
        setup_requires = build_backend.get_requires_for_build_wheel()
        assert setup_requires == ["wheel", "foo"]

    def test_dont_install_setup_requires(self, tmpdir_cwd):
        files = {
            'setup.py': DALS(
                """
                        from setuptools import setup

                        setup(
                            name="qux",
                            version="0.0.0",
                            py_modules=["hello"],
                            setup_requires=["does-not-exist >99"],
                        )
                    """
            ),
            'hello.py': DALS(
                """
                    def run():
                        print('hello')
                    """
            ),
        }

        path.build(files)

        build_backend = self.get_build_backend()

        dist_dir = os.path.abspath('pip-dist-info')
        os.makedirs(dist_dir)

        # does-not-exist can't be satisfied, so if it attempts to install
        # setup_requires, it will fail.
        build_backend.prepare_metadata_for_build_wheel(dist_dir)

    _sys_argv_0_passthrough = {
        'setup.py': DALS(
            """
            import os
            import sys

            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
            )

            sys_argv = os.path.abspath(sys.argv[0])
            file_path = os.path.abspath('setup.py')
            assert sys_argv == file_path
            """
        )
    }

    def test_sys_argv_passthrough(self, tmpdir_cwd):
        path.build(self._sys_argv_0_passthrough)
        build_backend = self.get_build_backend()
        with pytest.raises(AssertionError):
            build_backend.build_sdist("temp")

    _setup_py_file_abspath = {
        'setup.py': DALS(
            """
            import os
            assert os.path.isabs(__file__)
            __import__('setuptools').setup(
                name='foo',
                version='0.0.0',
                py_modules=['hello'],
                setup_requires=['six'],
            )
            """
        )
    }

    def test_setup_py_file_abspath(self, tmpdir_cwd):
        path.build(self._setup_py_file_abspath)
        build_backend = self.get_build_backend()
        build_backend.build_sdist("temp")

    @pytest.mark.parametrize('build_hook', ('build_sdist', 'build_wheel'))
    def test_build_with_empty_setuppy(self, build_backend, build_hook):
        files = {'setup.py': ''}
        path.build(files)

        with pytest.raises(ValueError, match=re.escape('No distribution was found.')):
            getattr(build_backend, build_hook)("temp")


class TestBuildMetaLegacyBackend(TestBuildMetaBackend):
    backend_name = 'setuptools.build_meta:__legacy__'

    # build_meta_legacy-specific tests
    def test_build_sdist_relative_path_import(self, tmpdir_cwd):
        # This must fail in build_meta, but must pass in build_meta_legacy
        path.build(self._relative_path_import_files)

        build_backend = self.get_build_backend()
        build_backend.build_sdist("temp")

    def test_sys_argv_passthrough(self, tmpdir_cwd):
        path.build(self._sys_argv_0_passthrough)

        build_backend = self.get_build_backend()
        build_backend.build_sdist("temp")


def test_legacy_editable_install(venv, tmpdir, tmpdir_cwd):
    pyproject = """
    [build-system]
    requires = ["setuptools"]
    build-backend = "setuptools.build_meta"
    [project]
    name = "myproj"
    version = "42"
    """
    path.build({"pyproject.toml": DALS(pyproject), "mymod.py": ""})

    # First: sanity check
    cmd = ["pip", "install", "--no-build-isolation", "-e", "."]
    output = str(venv.run(cmd, cwd=tmpdir), "utf-8").lower()
    assert "running setup.py develop for myproj" not in output
    assert "created wheel for myproj" in output

    # Then: real test
    env = {**os.environ, "SETUPTOOLS_ENABLE_FEATURES": "legacy-editable"}
    cmd = ["pip", "install", "--no-build-isolation", "-e", "."]
    output = str(venv.run(cmd, cwd=tmpdir, env=env), "utf-8").lower()
    assert "running setup.py develop for myproj" in output


@pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
def test_sys_exit_0_in_setuppy(monkeypatch, tmp_path):
    """Setuptools should be resilent to setup.py with ``sys.exit(0)`` (#3973)."""
    monkeypatch.chdir(tmp_path)
    setuppy = """
        import sys, setuptools
        setuptools.setup(name='foo', version='0.0.0')
        sys.exit(0)
        """
    (tmp_path / "setup.py").write_text(DALS(setuppy), encoding="utf-8")
    backend = BuildBackend(backend_name="setuptools.build_meta")
    assert backend.get_requires_for_build_wheel() == ["wheel"]


def test_system_exit_in_setuppy(monkeypatch, tmp_path):
    monkeypatch.chdir(tmp_path)
    setuppy = "import sys; sys.exit('some error')"
    (tmp_path / "setup.py").write_text(setuppy, encoding="utf-8")
    with pytest.raises(SystemExit, match="some error"):
        backend = BuildBackend(backend_name="setuptools.build_meta")
        backend.get_requires_for_build_wheel()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_build_py.py0000644000175100001730000002220714467657412022260 0ustar00runnerdockerimport os
import stat
import shutil
from pathlib import Path
from unittest.mock import Mock

import pytest
import jaraco.path

from setuptools import SetuptoolsDeprecationWarning
from setuptools.dist import Distribution

from .textwrap import DALS


def test_directories_in_package_data_glob(tmpdir_cwd):
    """
    Directories matching the glob in package_data should
    not be included in the package data.

    Regression test for #261.
    """
    dist = Distribution(
        dict(
            script_name='setup.py',
            script_args=['build_py'],
            packages=[''],
            package_data={'': ['path/*']},
        )
    )
    os.makedirs('path/subpath')
    dist.parse_command_line()
    dist.run_commands()


def test_recursive_in_package_data_glob(tmpdir_cwd):
    """
    Files matching recursive globs (**) in package_data should
    be included in the package data.

    #1806
    """
    dist = Distribution(
        dict(
            script_name='setup.py',
            script_args=['build_py'],
            packages=[''],
            package_data={'': ['path/**/data']},
        )
    )
    os.makedirs('path/subpath/subsubpath')
    open('path/subpath/subsubpath/data', 'w').close()

    dist.parse_command_line()
    dist.run_commands()

    assert stat.S_ISREG(
        os.stat('build/lib/path/subpath/subsubpath/data').st_mode
    ), "File is not included"


def test_read_only(tmpdir_cwd):
    """
    Ensure read-only flag is not preserved in copy
    for package modules and package data, as that
    causes problems with deleting read-only files on
    Windows.

    #1451
    """
    dist = Distribution(
        dict(
            script_name='setup.py',
            script_args=['build_py'],
            packages=['pkg'],
            package_data={'pkg': ['data.dat']},
        )
    )
    os.makedirs('pkg')
    open('pkg/__init__.py', 'w').close()
    open('pkg/data.dat', 'w').close()
    os.chmod('pkg/__init__.py', stat.S_IREAD)
    os.chmod('pkg/data.dat', stat.S_IREAD)
    dist.parse_command_line()
    dist.run_commands()
    shutil.rmtree('build')


@pytest.mark.xfail(
    'platform.system() == "Windows"',
    reason="On Windows, files do not have executable bits",
    raises=AssertionError,
    strict=True,
)
def test_executable_data(tmpdir_cwd):
    """
    Ensure executable bit is preserved in copy for
    package data, as users rely on it for scripts.

    #2041
    """
    dist = Distribution(
        dict(
            script_name='setup.py',
            script_args=['build_py'],
            packages=['pkg'],
            package_data={'pkg': ['run-me']},
        )
    )
    os.makedirs('pkg')
    open('pkg/__init__.py', 'w').close()
    open('pkg/run-me', 'w').close()
    os.chmod('pkg/run-me', 0o700)

    dist.parse_command_line()
    dist.run_commands()

    assert (
        os.stat('build/lib/pkg/run-me').st_mode & stat.S_IEXEC
    ), "Script is not executable"


EXAMPLE_WITH_MANIFEST = {
    "setup.cfg": DALS(
        """
        [metadata]
        name = mypkg
        version = 42

        [options]
        include_package_data = True
        packages = find:

        [options.packages.find]
        exclude = *.tests*
        """
    ),
    "mypkg": {
        "__init__.py": "",
        "resource_file.txt": "",
        "tests": {
            "__init__.py": "",
            "test_mypkg.py": "",
            "test_file.txt": "",
        },
    },
    "MANIFEST.in": DALS(
        """
        global-include *.py *.txt
        global-exclude *.py[cod]
        prune dist
        prune build
        prune *.egg-info
        """
    ),
}


def test_excluded_subpackages(tmpdir_cwd):
    jaraco.path.build(EXAMPLE_WITH_MANIFEST)
    dist = Distribution({"script_name": "%PEP 517%"})
    dist.parse_config_files()

    build_py = dist.get_command_obj("build_py")
    msg = r"Python recognizes 'mypkg\.tests' as an importable package"
    with pytest.warns(SetuptoolsDeprecationWarning, match=msg):
        # TODO: To fix #3260 we need some transition period to deprecate the
        # existing behavior of `include_package_data`. After the transition, we
        # should remove the warning and fix the behaviour.
        build_py.finalize_options()
        build_py.run()

    build_dir = Path(dist.get_command_obj("build_py").build_lib)
    assert (build_dir / "mypkg/__init__.py").exists()
    assert (build_dir / "mypkg/resource_file.txt").exists()

    # Setuptools is configured to ignore `mypkg.tests`, therefore the following
    # files/dirs should not be included in the distribution.
    for f in [
        "mypkg/tests/__init__.py",
        "mypkg/tests/test_mypkg.py",
        "mypkg/tests/test_file.txt",
        "mypkg/tests",
    ]:
        with pytest.raises(AssertionError):
            # TODO: Enforce the following assertion once #3260 is fixed
            # (remove context manager and the following xfail).
            assert not (build_dir / f).exists()

    pytest.xfail("#3260")


@pytest.mark.filterwarnings("ignore::setuptools.SetuptoolsDeprecationWarning")
def test_existing_egg_info(tmpdir_cwd, monkeypatch):
    """When provided with the ``existing_egg_info_dir`` attribute, build_py should not
    attempt to run egg_info again.
    """
    # == Pre-condition ==
    # Generate an egg-info dir
    jaraco.path.build(EXAMPLE_WITH_MANIFEST)
    dist = Distribution({"script_name": "%PEP 517%"})
    dist.parse_config_files()
    assert dist.include_package_data

    egg_info = dist.get_command_obj("egg_info")
    dist.run_command("egg_info")
    egg_info_dir = next(Path(egg_info.egg_base).glob("*.egg-info"))
    assert egg_info_dir.is_dir()

    # == Setup ==
    build_py = dist.get_command_obj("build_py")
    build_py.finalize_options()
    egg_info = dist.get_command_obj("egg_info")
    egg_info_run = Mock(side_effect=egg_info.run)
    monkeypatch.setattr(egg_info, "run", egg_info_run)

    # == Remove caches ==
    # egg_info is called when build_py looks for data_files, which gets cached.
    # We need to ensure it is not cached yet, otherwise it may impact on the tests
    build_py.__dict__.pop('data_files', None)
    dist.reinitialize_command(egg_info)

    # == Sanity check ==
    # Ensure that if existing_egg_info is not given, build_py attempts to run egg_info
    build_py.existing_egg_info_dir = None
    build_py.run()
    egg_info_run.assert_called()

    # == Remove caches ==
    egg_info_run.reset_mock()
    build_py.__dict__.pop('data_files', None)
    dist.reinitialize_command(egg_info)

    # == Actual test ==
    # Ensure that if existing_egg_info_dir is given, egg_info doesn't run
    build_py.existing_egg_info_dir = egg_info_dir
    build_py.run()
    egg_info_run.assert_not_called()
    assert build_py.data_files

    # Make sure the list of outputs is actually OK
    outputs = map(lambda x: x.replace(os.sep, "/"), build_py.get_outputs())
    assert outputs
    example = str(Path(build_py.build_lib, "mypkg/__init__.py")).replace(os.sep, "/")
    assert example in outputs


EXAMPLE_ARBITRARY_MAPPING = {
    "pyproject.toml": DALS(
        """
        [project]
        name = "mypkg"
        version = "42"

        [tool.setuptools]
        packages = ["mypkg", "mypkg.sub1", "mypkg.sub2", "mypkg.sub2.nested"]

        [tool.setuptools.package-dir]
        "" = "src"
        "mypkg.sub2" = "src/mypkg/_sub2"
        "mypkg.sub2.nested" = "other"
        """
    ),
    "src": {
        "mypkg": {
            "__init__.py": "",
            "resource_file.txt": "",
            "sub1": {
                "__init__.py": "",
                "mod1.py": "",
            },
            "_sub2": {
                "mod2.py": "",
            },
        },
    },
    "other": {
        "__init__.py": "",
        "mod3.py": "",
    },
    "MANIFEST.in": DALS(
        """
        global-include *.py *.txt
        global-exclude *.py[cod]
        """
    ),
}


def test_get_outputs(tmpdir_cwd):
    jaraco.path.build(EXAMPLE_ARBITRARY_MAPPING)
    dist = Distribution({"script_name": "%test%"})
    dist.parse_config_files()

    build_py = dist.get_command_obj("build_py")
    build_py.editable_mode = True
    build_py.ensure_finalized()
    build_lib = build_py.build_lib.replace(os.sep, "/")
    outputs = {x.replace(os.sep, "/") for x in build_py.get_outputs()}
    assert outputs == {
        f"{build_lib}/mypkg/__init__.py",
        f"{build_lib}/mypkg/resource_file.txt",
        f"{build_lib}/mypkg/sub1/__init__.py",
        f"{build_lib}/mypkg/sub1/mod1.py",
        f"{build_lib}/mypkg/sub2/mod2.py",
        f"{build_lib}/mypkg/sub2/nested/__init__.py",
        f"{build_lib}/mypkg/sub2/nested/mod3.py",
    }
    mapping = {
        k.replace(os.sep, "/"): v.replace(os.sep, "/")
        for k, v in build_py.get_output_mapping().items()
    }
    assert mapping == {
        f"{build_lib}/mypkg/__init__.py": "src/mypkg/__init__.py",
        f"{build_lib}/mypkg/resource_file.txt": "src/mypkg/resource_file.txt",
        f"{build_lib}/mypkg/sub1/__init__.py": "src/mypkg/sub1/__init__.py",
        f"{build_lib}/mypkg/sub1/mod1.py": "src/mypkg/sub1/mod1.py",
        f"{build_lib}/mypkg/sub2/mod2.py": "src/mypkg/_sub2/mod2.py",
        f"{build_lib}/mypkg/sub2/nested/__init__.py": "other/__init__.py",
        f"{build_lib}/mypkg/sub2/nested/mod3.py": "other/mod3.py",
    }
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_config_discovery.py0000644000175100001730000005322714467657412024013 0ustar00runnerdockerimport os
import sys
from configparser import ConfigParser
from itertools import product

from setuptools.command.sdist import sdist
from setuptools.dist import Distribution
from setuptools.discovery import find_package_path, find_parent_package
from setuptools.errors import PackageDiscoveryError

import setuptools  # noqa -- force distutils.core to be patched
import distutils.core

import pytest
import jaraco.path
from path import Path as _Path

from .contexts import quiet
from .integration.helpers import get_sdist_members, get_wheel_members, run
from .textwrap import DALS


class TestFindParentPackage:
    def test_single_package(self, tmp_path):
        # find_parent_package should find a non-namespace parent package
        (tmp_path / "src/namespace/pkg/nested").mkdir(exist_ok=True, parents=True)
        (tmp_path / "src/namespace/pkg/nested/__init__.py").touch()
        (tmp_path / "src/namespace/pkg/__init__.py").touch()
        packages = ["namespace", "namespace.pkg", "namespace.pkg.nested"]
        assert find_parent_package(packages, {"": "src"}, tmp_path) == "namespace.pkg"

    def test_multiple_toplevel(self, tmp_path):
        # find_parent_package should return null if the given list of packages does not
        # have a single parent package
        multiple = ["pkg", "pkg1", "pkg2"]
        for name in multiple:
            (tmp_path / f"src/{name}").mkdir(exist_ok=True, parents=True)
            (tmp_path / f"src/{name}/__init__.py").touch()
        assert find_parent_package(multiple, {"": "src"}, tmp_path) is None


class TestDiscoverPackagesAndPyModules:
    """Make sure discovered values for ``packages`` and ``py_modules`` work
    similarly to explicit configuration for the simple scenarios.
    """

    OPTIONS = {
        # Different options according to the circumstance being tested
        "explicit-src": {"package_dir": {"": "src"}, "packages": ["pkg"]},
        "variation-lib": {
            "package_dir": {"": "lib"},  # variation of the source-layout
        },
        "explicit-flat": {"packages": ["pkg"]},
        "explicit-single_module": {"py_modules": ["pkg"]},
        "explicit-namespace": {"packages": ["ns", "ns.pkg"]},
        "automatic-src": {},
        "automatic-flat": {},
        "automatic-single_module": {},
        "automatic-namespace": {},
    }
    FILES = {
        "src": ["src/pkg/__init__.py", "src/pkg/main.py"],
        "lib": ["lib/pkg/__init__.py", "lib/pkg/main.py"],
        "flat": ["pkg/__init__.py", "pkg/main.py"],
        "single_module": ["pkg.py"],
        "namespace": ["ns/pkg/__init__.py"],
    }

    def _get_info(self, circumstance):
        _, _, layout = circumstance.partition("-")
        files = self.FILES[layout]
        options = self.OPTIONS[circumstance]
        return files, options

    @pytest.mark.parametrize("circumstance", OPTIONS.keys())
    def test_sdist_filelist(self, tmp_path, circumstance):
        files, options = self._get_info(circumstance)
        _populate_project_dir(tmp_path, files, options)

        _, cmd = _run_sdist_programatically(tmp_path, options)

        manifest = [f.replace(os.sep, "/") for f in cmd.filelist.files]
        for file in files:
            assert any(f.endswith(file) for f in manifest)

    @pytest.mark.parametrize("circumstance", OPTIONS.keys())
    def test_project(self, tmp_path, circumstance):
        files, options = self._get_info(circumstance)
        _populate_project_dir(tmp_path, files, options)

        # Simulate a pre-existing `build` directory
        (tmp_path / "build").mkdir()
        (tmp_path / "build/lib").mkdir()
        (tmp_path / "build/bdist.linux-x86_64").mkdir()
        (tmp_path / "build/bdist.linux-x86_64/file.py").touch()
        (tmp_path / "build/lib/__init__.py").touch()
        (tmp_path / "build/lib/file.py").touch()
        (tmp_path / "dist").mkdir()
        (tmp_path / "dist/file.py").touch()

        _run_build(tmp_path)

        sdist_files = get_sdist_members(next(tmp_path.glob("dist/*.tar.gz")))
        print("~~~~~ sdist_members ~~~~~")
        print('\n'.join(sdist_files))
        assert sdist_files >= set(files)

        wheel_files = get_wheel_members(next(tmp_path.glob("dist/*.whl")))
        print("~~~~~ wheel_members ~~~~~")
        print('\n'.join(wheel_files))
        orig_files = {f.replace("src/", "").replace("lib/", "") for f in files}
        assert wheel_files >= orig_files

        # Make sure build files are not included by mistake
        for file in wheel_files:
            assert "build" not in files
            assert "dist" not in files

    PURPOSEFULLY_EMPY = {
        "setup.cfg": DALS(
            """
            [metadata]
            name = myproj
            version = 0.0.0

            [options]
            {param} =
            """
        ),
        "setup.py": DALS(
            """
            __import__('setuptools').setup(
                name="myproj",
                version="0.0.0",
                {param}=[]
            )
            """
        ),
        "pyproject.toml": DALS(
            """
            [build-system]
            requires = []
            build-backend = 'setuptools.build_meta'

            [project]
            name = "myproj"
            version = "0.0.0"

            [tool.setuptools]
            {param} = []
            """
        ),
        "template-pyproject.toml": DALS(
            """
            [build-system]
            requires = []
            build-backend = 'setuptools.build_meta'
            """
        ),
    }

    @pytest.mark.parametrize(
        "config_file, param, circumstance",
        product(
            ["setup.cfg", "setup.py", "pyproject.toml"],
            ["packages", "py_modules"],
            FILES.keys(),
        ),
    )
    def test_purposefully_empty(self, tmp_path, config_file, param, circumstance):
        files = self.FILES[circumstance] + ["mod.py", "other.py", "src/pkg/__init__.py"]
        _populate_project_dir(tmp_path, files, {})

        if config_file == "pyproject.toml":
            template_param = param.replace("_", "-")
        else:
            # Make sure build works with or without setup.cfg
            pyproject = self.PURPOSEFULLY_EMPY["template-pyproject.toml"]
            (tmp_path / "pyproject.toml").write_text(pyproject)
            template_param = param

        config = self.PURPOSEFULLY_EMPY[config_file].format(param=template_param)
        (tmp_path / config_file).write_text(config)

        dist = _get_dist(tmp_path, {})
        # When either parameter package or py_modules is an empty list,
        # then there should be no discovery
        assert getattr(dist, param) == []
        other = {"py_modules": "packages", "packages": "py_modules"}[param]
        assert getattr(dist, other) is None

    @pytest.mark.parametrize(
        "extra_files, pkgs",
        [
            (["venv/bin/simulate_venv"], {"pkg"}),
            (["pkg-stubs/__init__.pyi"], {"pkg", "pkg-stubs"}),
            (["other-stubs/__init__.pyi"], {"pkg", "other-stubs"}),
            (
                # Type stubs can also be namespaced
                ["namespace-stubs/pkg/__init__.pyi"],
                {"pkg", "namespace-stubs", "namespace-stubs.pkg"},
            ),
            (
                # Just the top-level package can have `-stubs`, ignore nested ones
                ["namespace-stubs/pkg-stubs/__init__.pyi"],
                {"pkg", "namespace-stubs"},
            ),
            (["_hidden/file.py"], {"pkg"}),
            (["news/finalize.py"], {"pkg"}),
        ],
    )
    def test_flat_layout_with_extra_files(self, tmp_path, extra_files, pkgs):
        files = self.FILES["flat"] + extra_files
        _populate_project_dir(tmp_path, files, {})
        dist = _get_dist(tmp_path, {})
        assert set(dist.packages) == pkgs

    @pytest.mark.parametrize(
        "extra_files",
        [
            ["other/__init__.py"],
            ["other/finalize.py"],
        ],
    )
    def test_flat_layout_with_dangerous_extra_files(self, tmp_path, extra_files):
        files = self.FILES["flat"] + extra_files
        _populate_project_dir(tmp_path, files, {})
        with pytest.raises(PackageDiscoveryError, match="multiple (packages|modules)"):
            _get_dist(tmp_path, {})

    def test_flat_layout_with_single_module(self, tmp_path):
        files = self.FILES["single_module"] + ["invalid-module-name.py"]
        _populate_project_dir(tmp_path, files, {})
        dist = _get_dist(tmp_path, {})
        assert set(dist.py_modules) == {"pkg"}

    def test_flat_layout_with_multiple_modules(self, tmp_path):
        files = self.FILES["single_module"] + ["valid_module_name.py"]
        _populate_project_dir(tmp_path, files, {})
        with pytest.raises(PackageDiscoveryError, match="multiple (packages|modules)"):
            _get_dist(tmp_path, {})

    def test_py_modules_when_wheel_dir_is_cwd(self, tmp_path):
        """Regression for issue 3692"""
        from setuptools import build_meta

        pyproject = '[project]\nname = "test"\nversion = "1"'
        (tmp_path / "pyproject.toml").write_text(DALS(pyproject), encoding="utf-8")
        (tmp_path / "foo.py").touch()
        with jaraco.path.DirectoryStack().context(tmp_path):
            build_meta.build_wheel(".")
        # Ensure py_modules are found
        wheel_files = get_wheel_members(next(tmp_path.glob("*.whl")))
        assert "foo.py" in wheel_files


class TestNoConfig:
    DEFAULT_VERSION = "0.0.0"  # Default version given by setuptools

    EXAMPLES = {
        "pkg1": ["src/pkg1.py"],
        "pkg2": ["src/pkg2/__init__.py"],
        "pkg3": ["src/pkg3/__init__.py", "src/pkg3-stubs/__init__.py"],
        "pkg4": ["pkg4/__init__.py", "pkg4-stubs/__init__.py"],
        "ns.nested.pkg1": ["src/ns/nested/pkg1/__init__.py"],
        "ns.nested.pkg2": ["ns/nested/pkg2/__init__.py"],
    }

    @pytest.mark.parametrize("example", EXAMPLES.keys())
    def test_discover_name(self, tmp_path, example):
        _populate_project_dir(tmp_path, self.EXAMPLES[example], {})
        dist = _get_dist(tmp_path, {})
        assert dist.get_name() == example

    def test_build_with_discovered_name(self, tmp_path):
        files = ["src/ns/nested/pkg/__init__.py"]
        _populate_project_dir(tmp_path, files, {})
        _run_build(tmp_path, "--sdist")
        # Expected distribution file
        dist_file = tmp_path / f"dist/ns.nested.pkg-{self.DEFAULT_VERSION}.tar.gz"
        assert dist_file.is_file()


class TestWithAttrDirective:
    @pytest.mark.parametrize(
        "folder, opts",
        [
            ("src", {}),
            ("lib", {"packages": "find:", "packages.find": {"where": "lib"}}),
        ],
    )
    def test_setupcfg_metadata(self, tmp_path, folder, opts):
        files = [f"{folder}/pkg/__init__.py", "setup.cfg"]
        _populate_project_dir(tmp_path, files, opts)
        (tmp_path / folder / "pkg/__init__.py").write_text("version = 42")
        (tmp_path / "setup.cfg").write_text(
            "[metadata]\nversion = attr: pkg.version\n"
            + (tmp_path / "setup.cfg").read_text()
        )

        dist = _get_dist(tmp_path, {})
        assert dist.get_name() == "pkg"
        assert dist.get_version() == "42"
        assert dist.package_dir
        package_path = find_package_path("pkg", dist.package_dir, tmp_path)
        assert os.path.exists(package_path)
        assert folder in _Path(package_path).parts()

        _run_build(tmp_path, "--sdist")
        dist_file = tmp_path / "dist/pkg-42.tar.gz"
        assert dist_file.is_file()

    def test_pyproject_metadata(self, tmp_path):
        _populate_project_dir(tmp_path, ["src/pkg/__init__.py"], {})
        (tmp_path / "src/pkg/__init__.py").write_text("version = 42")
        (tmp_path / "pyproject.toml").write_text(
            "[project]\nname = 'pkg'\ndynamic = ['version']\n"
            "[tool.setuptools.dynamic]\nversion = {attr = 'pkg.version'}\n"
        )
        dist = _get_dist(tmp_path, {})
        assert dist.get_version() == "42"
        assert dist.package_dir == {"": "src"}


class TestWithCExtension:
    def _simulate_package_with_extension(self, tmp_path):
        # This example is based on: https://github.com/nucleic/kiwi/tree/1.4.0
        files = [
            "benchmarks/file.py",
            "docs/Makefile",
            "docs/requirements.txt",
            "docs/source/conf.py",
            "proj/header.h",
            "proj/file.py",
            "py/proj.cpp",
            "py/other.cpp",
            "py/file.py",
            "py/py.typed",
            "py/tests/test_proj.py",
            "README.rst",
        ]
        _populate_project_dir(tmp_path, files, {})

        setup_script = """
            from setuptools import Extension, setup

            ext_modules = [
                Extension(
                    "proj",
                    ["py/proj.cpp", "py/other.cpp"],
                    include_dirs=["."],
                    language="c++",
                ),
            ]
            setup(ext_modules=ext_modules)
        """
        (tmp_path / "setup.py").write_text(DALS(setup_script))

    def test_skip_discovery_with_setupcfg_metadata(self, tmp_path):
        """Ensure that auto-discovery is not triggered when the project is based on
        C-extensions only, for backward compatibility.
        """
        self._simulate_package_with_extension(tmp_path)

        pyproject = """
            [build-system]
            requires = []
            build-backend = 'setuptools.build_meta'
        """
        (tmp_path / "pyproject.toml").write_text(DALS(pyproject))

        setupcfg = """
            [metadata]
            name = proj
            version = 42
        """
        (tmp_path / "setup.cfg").write_text(DALS(setupcfg))

        dist = _get_dist(tmp_path, {})
        assert dist.get_name() == "proj"
        assert dist.get_version() == "42"
        assert dist.py_modules is None
        assert dist.packages is None
        assert len(dist.ext_modules) == 1
        assert dist.ext_modules[0].name == "proj"

    def test_dont_skip_discovery_with_pyproject_metadata(self, tmp_path):
        """When opting-in to pyproject.toml metadata, auto-discovery will be active if
        the package lists C-extensions, but does not configure py-modules or packages.

        This way we ensure users with complex package layouts that would lead to the
        discovery of multiple top-level modules/packages see errors and are forced to
        explicitly set ``packages`` or ``py-modules``.
        """
        self._simulate_package_with_extension(tmp_path)

        pyproject = """
            [project]
            name = 'proj'
            version = '42'
        """
        (tmp_path / "pyproject.toml").write_text(DALS(pyproject))
        with pytest.raises(PackageDiscoveryError, match="multiple (packages|modules)"):
            _get_dist(tmp_path, {})


class TestWithPackageData:
    def _simulate_package_with_data_files(self, tmp_path, src_root):
        files = [
            f"{src_root}/proj/__init__.py",
            f"{src_root}/proj/file1.txt",
            f"{src_root}/proj/nested/file2.txt",
        ]
        _populate_project_dir(tmp_path, files, {})

        manifest = """
            global-include *.py *.txt
        """
        (tmp_path / "MANIFEST.in").write_text(DALS(manifest))

    EXAMPLE_SETUPCFG = """
    [metadata]
    name = proj
    version = 42

    [options]
    include_package_data = True
    """
    EXAMPLE_PYPROJECT = """
    [project]
    name = "proj"
    version = "42"
    """

    PYPROJECT_PACKAGE_DIR = """
    [tool.setuptools]
    package-dir = {"" = "src"}
    """

    @pytest.mark.parametrize(
        "src_root, files",
        [
            (".", {"setup.cfg": DALS(EXAMPLE_SETUPCFG)}),
            (".", {"pyproject.toml": DALS(EXAMPLE_PYPROJECT)}),
            ("src", {"setup.cfg": DALS(EXAMPLE_SETUPCFG)}),
            ("src", {"pyproject.toml": DALS(EXAMPLE_PYPROJECT)}),
            (
                "src",
                {
                    "setup.cfg": DALS(EXAMPLE_SETUPCFG)
                    + DALS(
                        """
                        packages = find:
                        package_dir =
                            =src

                        [options.packages.find]
                        where = src
                        """
                    )
                },
            ),
            (
                "src",
                {
                    "pyproject.toml": DALS(EXAMPLE_PYPROJECT)
                    + DALS(
                        """
                        [tool.setuptools]
                        package-dir = {"" = "src"}
                        """
                    )
                },
            ),
        ],
    )
    def test_include_package_data(self, tmp_path, src_root, files):
        """
        Make sure auto-discovery does not affect package include_package_data.
        See issue #3196.
        """
        jaraco.path.build(files, prefix=str(tmp_path))
        self._simulate_package_with_data_files(tmp_path, src_root)

        expected = {
            os.path.normpath(f"{src_root}/proj/file1.txt").replace(os.sep, "/"),
            os.path.normpath(f"{src_root}/proj/nested/file2.txt").replace(os.sep, "/"),
        }

        _run_build(tmp_path)

        sdist_files = get_sdist_members(next(tmp_path.glob("dist/*.tar.gz")))
        print("~~~~~ sdist_members ~~~~~")
        print('\n'.join(sdist_files))
        assert sdist_files >= expected

        wheel_files = get_wheel_members(next(tmp_path.glob("dist/*.whl")))
        print("~~~~~ wheel_members ~~~~~")
        print('\n'.join(wheel_files))
        orig_files = {f.replace("src/", "").replace("lib/", "") for f in expected}
        assert wheel_files >= orig_files


def test_compatible_with_numpy_configuration(tmp_path):
    files = [
        "dir1/__init__.py",
        "dir2/__init__.py",
        "file.py",
    ]
    _populate_project_dir(tmp_path, files, {})
    dist = Distribution({})
    dist.configuration = object()
    dist.set_defaults()
    assert dist.py_modules is None
    assert dist.packages is None


def test_name_discovery_doesnt_break_cli(tmpdir_cwd):
    jaraco.path.build({"pkg.py": ""})
    dist = Distribution({})
    dist.script_args = ["--name"]
    dist.set_defaults()
    dist.parse_command_line()  # <-- no exception should be raised here.
    assert dist.get_name() == "pkg"


def test_preserve_explicit_name_with_dynamic_version(tmpdir_cwd, monkeypatch):
    """According to #3545 it seems that ``name`` discovery is running,
    even when the project already explicitly sets it.
    This seems to be related to parsing of dynamic versions (via ``attr`` directive),
    which requires the auto-discovery of ``package_dir``.
    """
    files = {
        "src": {
            "pkg": {"__init__.py": "__version__ = 42\n"},
        },
        "pyproject.toml": DALS(
            """
            [project]
            name = "myproj"  # purposefully different from package name
            dynamic = ["version"]
            [tool.setuptools.dynamic]
            version = {"attr" = "pkg.__version__"}
            """
        ),
    }
    jaraco.path.build(files)
    dist = Distribution({})
    orig_analyse_name = dist.set_defaults.analyse_name

    def spy_analyse_name():
        # We can check if name discovery was triggered by ensuring the original
        # name remains instead of the package name.
        orig_analyse_name()
        assert dist.get_name() == "myproj"

    monkeypatch.setattr(dist.set_defaults, "analyse_name", spy_analyse_name)
    dist.parse_config_files()
    assert dist.get_version() == "42"
    assert set(dist.packages) == {"pkg"}


def _populate_project_dir(root, files, options):
    # NOTE: Currently pypa/build will refuse to build the project if no
    # `pyproject.toml` or `setup.py` is found. So it is impossible to do
    # completely "config-less" projects.
    (root / "setup.py").write_text("import setuptools\nsetuptools.setup()")
    (root / "README.md").write_text("# Example Package")
    (root / "LICENSE").write_text("Copyright (c) 2018")
    _write_setupcfg(root, options)
    paths = (root / f for f in files)
    for path in paths:
        path.parent.mkdir(exist_ok=True, parents=True)
        path.touch()


def _write_setupcfg(root, options):
    if not options:
        print("~~~~~ **NO** setup.cfg ~~~~~")
        return
    setupcfg = ConfigParser()
    setupcfg.add_section("options")
    for key, value in options.items():
        if key == "packages.find":
            setupcfg.add_section(f"options.{key}")
            setupcfg[f"options.{key}"].update(value)
        elif isinstance(value, list):
            setupcfg["options"][key] = ", ".join(value)
        elif isinstance(value, dict):
            str_value = "\n".join(f"\t{k} = {v}" for k, v in value.items())
            setupcfg["options"][key] = "\n" + str_value
        else:
            setupcfg["options"][key] = str(value)
    with open(root / "setup.cfg", "w") as f:
        setupcfg.write(f)
    print("~~~~~ setup.cfg ~~~~~")
    print((root / "setup.cfg").read_text())


def _run_build(path, *flags):
    cmd = [sys.executable, "-m", "build", "--no-isolation", *flags, str(path)]
    return run(cmd, env={'DISTUTILS_DEBUG': ''})


def _get_dist(dist_path, attrs):
    root = "/".join(os.path.split(dist_path))  # POSIX-style

    script = dist_path / 'setup.py'
    if script.exists():
        with _Path(dist_path):
            dist = distutils.core.run_setup("setup.py", {}, stop_after="init")
    else:
        dist = Distribution(attrs)

    dist.src_root = root
    dist.script_name = "setup.py"
    with _Path(dist_path):
        dist.parse_config_files()

    dist.set_defaults()
    return dist


def _run_sdist_programatically(dist_path, attrs):
    dist = _get_dist(dist_path, attrs)
    cmd = sdist(dist)
    cmd.ensure_finalized()
    assert cmd.distribution.packages or cmd.distribution.py_modules

    with quiet(), _Path(dist_path):
        cmd.run()

    return dist, cmd
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_dep_util.py0000644000175100001730000000172114467657412022254 0ustar00runnerdockerfrom setuptools.dep_util import newer_pairwise_group
import os
import pytest


@pytest.fixture
def groups_target(tmpdir):
    """Sets up some older sources, a target and newer sources.
    Returns a 3-tuple in this order.
    """
    creation_order = ['older.c', 'older.h', 'target.o', 'newer.c', 'newer.h']
    mtime = 0

    for i in range(len(creation_order)):
        creation_order[i] = os.path.join(str(tmpdir), creation_order[i])
        with open(creation_order[i], 'w'):
            pass

        # make sure modification times are sequential
        os.utime(creation_order[i], (mtime, mtime))
        mtime += 1

    return creation_order[:2], creation_order[2], creation_order[3:]


def test_newer_pairwise_group(groups_target):
    older = newer_pairwise_group([groups_target[0]], [groups_target[1]])
    newer = newer_pairwise_group([groups_target[2]], [groups_target[1]])
    assert older == ([], [])
    assert newer == ([groups_target[2]], [groups_target[1]])
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_depends.py0000644000175100001730000000065014467657412022071 0ustar00runnerdockerimport sys

from setuptools import depends


class TestGetModuleConstant:
    def test_basic(self):
        """
        Invoke get_module_constant on a module in
        the test package.
        """
        mod_name = 'setuptools.tests.mod_with_constant'
        val = depends.get_module_constant(mod_name, 'value')
        assert val == 'three, sir!'
        assert 'setuptools.tests.mod_with_constant' not in sys.modules
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_develop.py0000644000175100001730000001117514467657412022111 0ustar00runnerdocker"""develop tests
"""

import os
import sys
import subprocess
import platform

from setuptools.command import test

import pytest

from setuptools.command.develop import develop
from setuptools.dist import Distribution
from . import contexts
from . import namespaces

SETUP_PY = """\
from setuptools import setup

setup(name='foo',
    packages=['foo'],
)
"""

INIT_PY = """print "foo"
"""


@pytest.fixture
def temp_user(monkeypatch):
    with contexts.tempdir() as user_base:
        with contexts.tempdir() as user_site:
            monkeypatch.setattr('site.USER_BASE', user_base)
            monkeypatch.setattr('site.USER_SITE', user_site)
            yield


@pytest.fixture
def test_env(tmpdir, temp_user):
    target = tmpdir
    foo = target.mkdir('foo')
    setup = target / 'setup.py'
    if setup.isfile():
        raise ValueError(dir(target))
    with setup.open('w') as f:
        f.write(SETUP_PY)
    init = foo / '__init__.py'
    with init.open('w') as f:
        f.write(INIT_PY)
    with target.as_cwd():
        yield target


class TestDevelop:
    in_virtualenv = hasattr(sys, 'real_prefix')
    in_venv = hasattr(sys, 'base_prefix') and sys.base_prefix != sys.prefix

    def test_console_scripts(self, tmpdir):
        """
        Test that console scripts are installed and that they reference
        only the project by name and not the current version.
        """
        pytest.skip(
            "TODO: needs a fixture to cause 'develop' "
            "to be invoked without mutating environment."
        )
        settings = dict(
            name='foo',
            packages=['foo'],
            version='0.0',
            entry_points={
                'console_scripts': [
                    'foocmd = foo:foo',
                ],
            },
        )
        dist = Distribution(settings)
        dist.script_name = 'setup.py'
        cmd = develop(dist)
        cmd.ensure_finalized()
        cmd.install_dir = tmpdir
        cmd.run()
        # assert '0.0' not in foocmd_text


class TestResolver:
    """
    TODO: These tests were written with a minimal understanding
    of what _resolve_setup_path is intending to do. Come up with
    more meaningful cases that look like real-world scenarios.
    """

    def test_resolve_setup_path_cwd(self):
        assert develop._resolve_setup_path('.', '.', '.') == '.'

    def test_resolve_setup_path_one_dir(self):
        assert develop._resolve_setup_path('pkgs', '.', 'pkgs') == '../'

    def test_resolve_setup_path_one_dir_trailing_slash(self):
        assert develop._resolve_setup_path('pkgs/', '.', 'pkgs') == '../'


class TestNamespaces:
    @staticmethod
    def install_develop(src_dir, target):
        develop_cmd = [
            sys.executable,
            'setup.py',
            'develop',
            '--install-dir',
            str(target),
        ]
        with src_dir.as_cwd():
            with test.test.paths_on_pythonpath([str(target)]):
                subprocess.check_call(develop_cmd)

    @pytest.mark.skipif(
        bool(os.environ.get("APPVEYOR")),
        reason="https://github.com/pypa/setuptools/issues/851",
    )
    @pytest.mark.skipif(
        platform.python_implementation() == 'PyPy',
        reason="https://github.com/pypa/setuptools/issues/1202",
    )
    def test_namespace_package_importable(self, tmpdir):
        """
        Installing two packages sharing the same namespace, one installed
        naturally using pip or `--single-version-externally-managed`
        and the other installed using `develop` should leave the namespace
        in tact and both packages reachable by import.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
        target = tmpdir / 'packages'
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip',
            'install',
            str(pkg_A),
            '-t',
            str(target),
        ]
        subprocess.check_call(install_cmd)
        self.install_develop(pkg_B, target)
        namespaces.make_site_dir(target)
        try_import = [
            sys.executable,
            '-c',
            'import myns.pkgA; import myns.pkgB',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(try_import)

        # additionally ensure that pkg_resources import works
        pkg_resources_imp = [
            sys.executable,
            '-c',
            'import pkg_resources',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(pkg_resources_imp)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_dist.py0000644000175100001730000004135714467657412021423 0ustar00runnerdockerimport io
import collections
import re
import functools
import os
import urllib.request
import urllib.parse
from distutils.errors import DistutilsSetupError
from setuptools.dist import (
    check_package_data,
    check_specifier,
    rfc822_escape,
    rfc822_unescape,
)
from setuptools import sic
from setuptools import Distribution

from .textwrap import DALS
from .test_easy_install import make_nspkg_sdist
from .test_find_packages import ensure_files

import pytest


def test_dist_fetch_build_egg(tmpdir):
    """
    Check multiple calls to `Distribution.fetch_build_egg` work as expected.
    """
    index = tmpdir.mkdir('index')
    index_url = urllib.parse.urljoin('file://', urllib.request.pathname2url(str(index)))

    def sdist_with_index(distname, version):
        dist_dir = index.mkdir(distname)
        dist_sdist = '%s-%s.tar.gz' % (distname, version)
        make_nspkg_sdist(str(dist_dir.join(dist_sdist)), distname, version)
        with dist_dir.join('index.html').open('w') as fp:
            fp.write(
                DALS(
                    '''
                
                {dist_sdist}

                
                '''
                ).format(dist_sdist=dist_sdist)
            )

    sdist_with_index('barbazquux', '3.2.0')
    sdist_with_index('barbazquux-runner', '2.11.1')
    with tmpdir.join('setup.cfg').open('w') as fp:
        fp.write(
            DALS(
                '''
            [easy_install]
            index_url = {index_url}
            '''
            ).format(index_url=index_url)
        )
    reqs = '''
    barbazquux-runner
    barbazquux
    '''.split()
    with tmpdir.as_cwd():
        dist = Distribution()
        dist.parse_config_files()
        resolved_dists = [dist.fetch_build_egg(r) for r in reqs]
    assert [dist.key for dist in resolved_dists if dist] == reqs


EXAMPLE_BASE_INFO = dict(
    name="package",
    version="0.0.1",
    author="Foo Bar",
    author_email="foo@bar.net",
    long_description="Long\ndescription",
    description="Short description",
    keywords=["one", "two"],
)


def __read_test_cases():
    base = EXAMPLE_BASE_INFO

    params = functools.partial(dict, base)

    test_cases = [
        ('Metadata version 1.0', params()),
        (
            'Metadata Version 1.0: Short long description',
            params(
                long_description='Short long description',
            ),
        ),
        (
            'Metadata version 1.1: Classifiers',
            params(
                classifiers=[
                    'Programming Language :: Python :: 3',
                    'Programming Language :: Python :: 3.7',
                    'License :: OSI Approved :: MIT License',
                ],
            ),
        ),
        (
            'Metadata version 1.1: Download URL',
            params(
                download_url='https://example.com',
            ),
        ),
        (
            'Metadata Version 1.2: Requires-Python',
            params(
                python_requires='>=3.7',
            ),
        ),
        pytest.param(
            'Metadata Version 1.2: Project-Url',
            params(project_urls=dict(Foo='https://example.bar')),
            marks=pytest.mark.xfail(
                reason="Issue #1578: project_urls not read",
            ),
        ),
        (
            'Metadata Version 2.1: Long Description Content Type',
            params(
                long_description_content_type='text/x-rst; charset=UTF-8',
            ),
        ),
        (
            'License',
            params(
                license='MIT',
            ),
        ),
        (
            'License multiline',
            params(
                license='This is a long license \nover multiple lines',
            ),
        ),
        pytest.param(
            'Metadata Version 2.1: Provides Extra',
            params(provides_extras=['foo', 'bar']),
            marks=pytest.mark.xfail(reason="provides_extras not read"),
        ),
        (
            'Missing author',
            dict(
                name='foo',
                version='1.0.0',
                author_email='snorri@sturluson.name',
            ),
        ),
        (
            'Missing author e-mail',
            dict(
                name='foo',
                version='1.0.0',
                author='Snorri Sturluson',
            ),
        ),
        (
            'Missing author and e-mail',
            dict(
                name='foo',
                version='1.0.0',
            ),
        ),
        (
            'Bypass normalized version',
            dict(
                name='foo',
                version=sic('1.0.0a'),
            ),
        ),
    ]

    return test_cases


@pytest.mark.parametrize('name,attrs', __read_test_cases())
def test_read_metadata(name, attrs):
    dist = Distribution(attrs)
    metadata_out = dist.metadata
    dist_class = metadata_out.__class__

    # Write to PKG_INFO and then load into a new metadata object
    PKG_INFO = io.StringIO()

    metadata_out.write_pkg_file(PKG_INFO)

    PKG_INFO.seek(0)
    metadata_in = dist_class()
    metadata_in.read_pkg_file(PKG_INFO)

    tested_attrs = [
        ('name', dist_class.get_name),
        ('version', dist_class.get_version),
        ('author', dist_class.get_contact),
        ('author_email', dist_class.get_contact_email),
        ('metadata_version', dist_class.get_metadata_version),
        ('provides', dist_class.get_provides),
        ('description', dist_class.get_description),
        ('long_description', dist_class.get_long_description),
        ('download_url', dist_class.get_download_url),
        ('keywords', dist_class.get_keywords),
        ('platforms', dist_class.get_platforms),
        ('obsoletes', dist_class.get_obsoletes),
        ('requires', dist_class.get_requires),
        ('classifiers', dist_class.get_classifiers),
        ('project_urls', lambda s: getattr(s, 'project_urls', {})),
        ('provides_extras', lambda s: getattr(s, 'provides_extras', set())),
    ]

    for attr, getter in tested_attrs:
        assert getter(metadata_in) == getter(metadata_out)


def __maintainer_test_cases():
    attrs = {"name": "package", "version": "1.0", "description": "xxx"}

    def merge_dicts(d1, d2):
        d1 = d1.copy()
        d1.update(d2)

        return d1

    test_cases = [
        ('No author, no maintainer', attrs.copy()),
        (
            'Author (no e-mail), no maintainer',
            merge_dicts(attrs, {'author': 'Author Name'}),
        ),
        (
            'Author (e-mail), no maintainer',
            merge_dicts(
                attrs, {'author': 'Author Name', 'author_email': 'author@name.com'}
            ),
        ),
        (
            'No author, maintainer (no e-mail)',
            merge_dicts(attrs, {'maintainer': 'Maintainer Name'}),
        ),
        (
            'No author, maintainer (e-mail)',
            merge_dicts(
                attrs,
                {
                    'maintainer': 'Maintainer Name',
                    'maintainer_email': 'maintainer@name.com',
                },
            ),
        ),
        (
            'Author (no e-mail), Maintainer (no-email)',
            merge_dicts(
                attrs, {'author': 'Author Name', 'maintainer': 'Maintainer Name'}
            ),
        ),
        (
            'Author (e-mail), Maintainer (e-mail)',
            merge_dicts(
                attrs,
                {
                    'author': 'Author Name',
                    'author_email': 'author@name.com',
                    'maintainer': 'Maintainer Name',
                    'maintainer_email': 'maintainer@name.com',
                },
            ),
        ),
        (
            'No author (e-mail), no maintainer (e-mail)',
            merge_dicts(
                attrs,
                {
                    'author_email': 'author@name.com',
                    'maintainer_email': 'maintainer@name.com',
                },
            ),
        ),
        ('Author unicode', merge_dicts(attrs, {'author': '鉄沢寛'})),
        ('Maintainer unicode', merge_dicts(attrs, {'maintainer': 'Jan Łukasiewicz'})),
    ]

    return test_cases


@pytest.mark.parametrize('name,attrs', __maintainer_test_cases())
def test_maintainer_author(name, attrs, tmpdir):
    tested_keys = {
        'author': 'Author',
        'author_email': 'Author-email',
        'maintainer': 'Maintainer',
        'maintainer_email': 'Maintainer-email',
    }

    # Generate a PKG-INFO file
    dist = Distribution(attrs)
    fn = tmpdir.mkdir('pkg_info')
    fn_s = str(fn)

    dist.metadata.write_pkg_info(fn_s)

    with io.open(str(fn.join('PKG-INFO')), 'r', encoding='utf-8') as f:
        raw_pkg_lines = f.readlines()

    # Drop blank lines and strip lines from default description
    pkg_lines = list(filter(None, raw_pkg_lines[:-2]))

    pkg_lines_set = set(pkg_lines)

    # Duplicate lines should not be generated
    assert len(pkg_lines) == len(pkg_lines_set)

    for fkey, dkey in tested_keys.items():
        val = attrs.get(dkey, None)
        if val is None:
            for line in pkg_lines:
                assert not line.startswith(fkey + ':')
        else:
            line = '%s: %s' % (fkey, val)
            assert line in pkg_lines_set


def test_provides_extras_deterministic_order():
    extras = collections.OrderedDict()
    extras['a'] = ['foo']
    extras['b'] = ['bar']
    attrs = dict(extras_require=extras)
    dist = Distribution(attrs)
    assert dist.metadata.provides_extras == ['a', 'b']
    attrs['extras_require'] = collections.OrderedDict(
        reversed(list(attrs['extras_require'].items()))
    )
    dist = Distribution(attrs)
    assert dist.metadata.provides_extras == ['b', 'a']


CHECK_PACKAGE_DATA_TESTS = (
    # Valid.
    (
        {
            '': ['*.txt', '*.rst'],
            'hello': ['*.msg'],
        },
        None,
    ),
    # Not a dictionary.
    (
        (
            ('', ['*.txt', '*.rst']),
            ('hello', ['*.msg']),
        ),
        (
            "'package_data' must be a dictionary mapping package"
            " names to lists of string wildcard patterns"
        ),
    ),
    # Invalid key type.
    (
        {
            400: ['*.txt', '*.rst'],
        },
        ("keys of 'package_data' dict must be strings (got 400)"),
    ),
    # Invalid value type.
    (
        {
            'hello': str('*.msg'),
        },
        (
            "\"values of 'package_data' dict\" "
            "must be a list of strings (got '*.msg')"
        ),
    ),
    # Invalid value type (generators are single use)
    (
        {
            'hello': (x for x in "generator"),
        },
        (
            "\"values of 'package_data' dict\" must be a list of strings "
            "(got =3.0, !=3.1'}
    dist = Distribution(attrs)
    check_specifier(dist, attrs, attrs['python_requires'])

    # invalid specifier value
    attrs = {'name': 'foo', 'python_requires': ['>=3.0', '!=3.1']}
    with pytest.raises(DistutilsSetupError):
        dist = Distribution(attrs)


@pytest.mark.parametrize(
    'content, result',
    (
        pytest.param(
            "Just a single line",
            None,
            id="single_line",
        ),
        pytest.param(
            "Multiline\nText\nwithout\nextra indents\n",
            None,
            id="multiline",
        ),
        pytest.param(
            "Multiline\n    With\n\nadditional\n  indentation",
            None,
            id="multiline_with_indentation",
        ),
        pytest.param(
            "  Leading whitespace",
            "Leading whitespace",
            id="remove_leading_whitespace",
        ),
        pytest.param(
            "  Leading whitespace\nIn\n    Multiline comment",
            "Leading whitespace\nIn\n    Multiline comment",
            id="remove_leading_whitespace_multiline",
        ),
    ),
)
def test_rfc822_unescape(content, result):
    assert (result or content) == rfc822_unescape(rfc822_escape(content))


def test_metadata_name():
    with pytest.raises(DistutilsSetupError, match='missing.*name'):
        Distribution()._validate_metadata()


@pytest.mark.parametrize(
    "dist_name, py_module",
    [
        ("my.pkg", "my_pkg"),
        ("my-pkg", "my_pkg"),
        ("my_pkg", "my_pkg"),
        ("pkg", "pkg"),
    ],
)
def test_dist_default_py_modules(tmp_path, dist_name, py_module):
    (tmp_path / f"{py_module}.py").touch()

    (tmp_path / "setup.py").touch()
    (tmp_path / "noxfile.py").touch()
    # ^-- make sure common tool files are ignored

    attrs = {**EXAMPLE_BASE_INFO, "name": dist_name, "src_root": str(tmp_path)}
    # Find `py_modules` corresponding to dist_name if not given
    dist = Distribution(attrs)
    dist.set_defaults()
    assert dist.py_modules == [py_module]
    # When `py_modules` is given, don't do anything
    dist = Distribution({**attrs, "py_modules": ["explicity_py_module"]})
    dist.set_defaults()
    assert dist.py_modules == ["explicity_py_module"]
    # When `packages` is given, don't do anything
    dist = Distribution({**attrs, "packages": ["explicity_package"]})
    dist.set_defaults()
    assert not dist.py_modules


@pytest.mark.parametrize(
    "dist_name, package_dir, package_files, packages",
    [
        ("my.pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
        ("my-pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
        ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/mod.py"], ["my_pkg"]),
        ("my.pkg", None, ["my/pkg/__init__.py"], ["my", "my.pkg"]),
        (
            "my_pkg",
            None,
            ["src/my_pkg/__init__.py", "src/my_pkg2/__init__.py"],
            ["my_pkg", "my_pkg2"],
        ),
        (
            "my_pkg",
            {"pkg": "lib", "pkg2": "lib2"},
            ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"],
            ["pkg", "pkg.nested", "pkg2"],
        ),
    ],
)
def test_dist_default_packages(
    tmp_path, dist_name, package_dir, package_files, packages
):
    ensure_files(tmp_path, package_files)

    (tmp_path / "setup.py").touch()
    (tmp_path / "noxfile.py").touch()
    # ^-- should not be included by default

    attrs = {
        **EXAMPLE_BASE_INFO,
        "name": dist_name,
        "src_root": str(tmp_path),
        "package_dir": package_dir,
    }
    # Find `packages` either corresponding to dist_name or inside src
    dist = Distribution(attrs)
    dist.set_defaults()
    assert not dist.py_modules
    assert not dist.py_modules
    assert set(dist.packages) == set(packages)
    # When `py_modules` is given, don't do anything
    dist = Distribution({**attrs, "py_modules": ["explicit_py_module"]})
    dist.set_defaults()
    assert not dist.packages
    assert set(dist.py_modules) == {"explicit_py_module"}
    # When `packages` is given, don't do anything
    dist = Distribution({**attrs, "packages": ["explicit_package"]})
    dist.set_defaults()
    assert not dist.py_modules
    assert set(dist.packages) == {"explicit_package"}


@pytest.mark.parametrize(
    "dist_name, package_dir, package_files",
    [
        ("my.pkg.nested", None, ["my/pkg/nested/__init__.py"]),
        ("my.pkg", None, ["my/pkg/__init__.py", "my/pkg/file.py"]),
        ("my_pkg", None, ["my_pkg.py"]),
        ("my_pkg", None, ["my_pkg/__init__.py", "my_pkg/nested/__init__.py"]),
        ("my_pkg", None, ["src/my_pkg/__init__.py", "src/my_pkg/nested/__init__.py"]),
        (
            "my_pkg",
            {"my_pkg": "lib", "my_pkg.lib2": "lib2"},
            ["lib/__init__.py", "lib/nested/__init__.pyt", "lib2/__init__.py"],
        ),
        # Should not try to guess a name from multiple py_modules/packages
        ("UNKNOWN", None, ["src/mod1.py", "src/mod2.py"]),
        ("UNKNOWN", None, ["src/pkg1/__ini__.py", "src/pkg2/__init__.py"]),
    ],
)
def test_dist_default_name(tmp_path, dist_name, package_dir, package_files):
    """Make sure dist.name is discovered from packages/py_modules"""
    ensure_files(tmp_path, package_files)
    attrs = {
        **EXAMPLE_BASE_INFO,
        "src_root": "/".join(os.path.split(tmp_path)),  # POSIX-style
        "package_dir": package_dir,
    }
    del attrs["name"]

    dist = Distribution(attrs)
    dist.set_defaults()
    assert dist.py_modules or dist.packages
    assert dist.get_name() == dist_name
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_dist_info.py0000644000175100001730000001563414467657412022435 0ustar00runnerdocker"""Test .dist-info style distributions.
"""
import pathlib
import re
import shutil
import subprocess
import sys
from functools import partial

import pytest

import pkg_resources
from setuptools.archive_util import unpack_archive
from .textwrap import DALS


read = partial(pathlib.Path.read_text, encoding="utf-8")


class TestDistInfo:
    metadata_base = DALS(
        """
        Metadata-Version: 1.2
        Requires-Dist: splort (==4)
        Provides-Extra: baz
        Requires-Dist: quux (>=1.1); extra == 'baz'
        """
    )

    @classmethod
    def build_metadata(cls, **kwargs):
        lines = ('{key}: {value}\n'.format(**locals()) for key, value in kwargs.items())
        return cls.metadata_base + ''.join(lines)

    @pytest.fixture
    def metadata(self, tmpdir):
        dist_info_name = 'VersionedDistribution-2.718.dist-info'
        versioned = tmpdir / dist_info_name
        versioned.mkdir()
        filename = versioned / 'METADATA'
        content = self.build_metadata(
            Name='VersionedDistribution',
        )
        filename.write_text(content, encoding='utf-8')

        dist_info_name = 'UnversionedDistribution.dist-info'
        unversioned = tmpdir / dist_info_name
        unversioned.mkdir()
        filename = unversioned / 'METADATA'
        content = self.build_metadata(
            Name='UnversionedDistribution',
            Version='0.3',
        )
        filename.write_text(content, encoding='utf-8')

        return str(tmpdir)

    def test_distinfo(self, metadata):
        dists = dict(
            (d.project_name, d) for d in pkg_resources.find_distributions(metadata)
        )

        assert len(dists) == 2, dists

        unversioned = dists['UnversionedDistribution']
        versioned = dists['VersionedDistribution']

        assert versioned.version == '2.718'  # from filename
        assert unversioned.version == '0.3'  # from METADATA

    def test_conditional_dependencies(self, metadata):
        specs = 'splort==4', 'quux>=1.1'
        requires = list(map(pkg_resources.Requirement.parse, specs))

        for d in pkg_resources.find_distributions(metadata):
            assert d.requires() == requires[:1]
            assert d.requires(extras=('baz',)) == [
                requires[0],
                pkg_resources.Requirement.parse('quux>=1.1;extra=="baz"'),
            ]
            assert d.extras == ['baz']

    def test_invalid_version(self, tmp_path):
        """
        Supplying an invalid version crashes dist_info.
        """
        config = "[metadata]\nname=proj\nversion=42\n[egg_info]\ntag_build=invalid!!!\n"
        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
        msg = re.compile("invalid version", re.M | re.I)
        proc = run_command_inner("dist_info", cwd=tmp_path, check=False)
        assert proc.returncode
        assert msg.search(proc.stdout)
        assert not list(tmp_path.glob("*.dist-info"))

    def test_tag_arguments(self, tmp_path):
        config = """
        [metadata]
        name=proj
        version=42
        [egg_info]
        tag_date=1
        tag_build=.post
        """
        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")

        print(run_command("dist_info", "--no-date", cwd=tmp_path))
        dist_info = next(tmp_path.glob("*.dist-info"))
        assert dist_info.name.startswith("proj-42")
        shutil.rmtree(dist_info)

        print(run_command("dist_info", "--tag-build", ".a", cwd=tmp_path))
        dist_info = next(tmp_path.glob("*.dist-info"))
        assert dist_info.name.startswith("proj-42a")

    @pytest.mark.parametrize("keep_egg_info", (False, True))
    def test_output_dir(self, tmp_path, keep_egg_info):
        config = "[metadata]\nname=proj\nversion=42\n"
        (tmp_path / "setup.cfg").write_text(config, encoding="utf-8")
        out = tmp_path / "__out"
        out.mkdir()
        opts = ["--keep-egg-info"] if keep_egg_info else []
        run_command("dist_info", "--output-dir", out, *opts, cwd=tmp_path)
        assert len(list(out.glob("*.dist-info"))) == 1
        assert len(list(tmp_path.glob("*.dist-info"))) == 0
        expected_egg_info = 1 if keep_egg_info else 0
        assert len(list(out.glob("*.egg-info"))) == expected_egg_info
        assert len(list(tmp_path.glob("*.egg-info"))) == 0
        assert len(list(out.glob("*.__bkp__"))) == 0
        assert len(list(tmp_path.glob("*.__bkp__"))) == 0


class TestWheelCompatibility:
    """Make sure the .dist-info directory produced with the ``dist_info`` command
    is the same as the one produced by ``bdist_wheel``.
    """

    SETUPCFG = DALS(
        """
    [metadata]
    name = {name}
    version = {version}

    [options]
    install_requires =
        foo>=12; sys_platform != "linux"

    [options.extras_require]
    test = pytest

    [options.entry_points]
    console_scripts =
        executable-name = my_package.module:function
    discover =
        myproj = my_package.other_module:function
    """
    )

    EGG_INFO_OPTS = [
        # Related: #3088 #2872
        ("", ""),
        (".post", "[egg_info]\ntag_build = post\n"),
        (".post", "[egg_info]\ntag_build = .post\n"),
        (".post", "[egg_info]\ntag_build = post\ntag_date = 1\n"),
        (".dev", "[egg_info]\ntag_build = .dev\n"),
        (".dev", "[egg_info]\ntag_build = .dev\ntag_date = 1\n"),
        ("a1", "[egg_info]\ntag_build = .a1\n"),
        ("+local", "[egg_info]\ntag_build = +local\n"),
    ]

    @pytest.mark.parametrize("name", "my-proj my_proj my.proj My.Proj".split())
    @pytest.mark.parametrize("version", ["0.42.13"])
    @pytest.mark.parametrize("suffix, cfg", EGG_INFO_OPTS)
    def test_dist_info_is_the_same_as_in_wheel(
        self, name, version, tmp_path, suffix, cfg
    ):
        config = self.SETUPCFG.format(name=name, version=version) + cfg

        for i in "dir_wheel", "dir_dist":
            (tmp_path / i).mkdir()
            (tmp_path / i / "setup.cfg").write_text(config, encoding="utf-8")

        run_command("bdist_wheel", cwd=tmp_path / "dir_wheel")
        wheel = next(tmp_path.glob("dir_wheel/dist/*.whl"))
        unpack_archive(wheel, tmp_path / "unpack")
        wheel_dist_info = next(tmp_path.glob("unpack/*.dist-info"))

        run_command("dist_info", cwd=tmp_path / "dir_dist")
        dist_info = next(tmp_path.glob("dir_dist/*.dist-info"))

        assert dist_info.name == wheel_dist_info.name
        assert dist_info.name.startswith(f"{name.replace('-', '_')}-{version}{suffix}")
        for file in "METADATA", "entry_points.txt":
            assert read(dist_info / file) == read(wheel_dist_info / file)


def run_command_inner(*cmd, **kwargs):
    opts = {
        "stderr": subprocess.STDOUT,
        "stdout": subprocess.PIPE,
        "text": True,
        'check': True,
        **kwargs,
    }
    cmd = [sys.executable, "-c", "__import__('setuptools').setup()", *map(str, cmd)]
    return subprocess.run(cmd, **opts)


def run_command(*args, **kwargs):
    return run_command_inner(*args, **kwargs).stdout
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_distutils_adoption.py0000644000175100001730000001155214467657412024373 0ustar00runnerdockerimport os
import sys
import functools
import platform
import textwrap

import pytest


IS_PYPY = '__pypy__' in sys.builtin_module_names


def popen_text(call):
    """
    Augment the Popen call with the parameters to ensure unicode text.
    """
    return (
        functools.partial(call, universal_newlines=True)
        if sys.version_info < (3, 7)
        else functools.partial(call, text=True)
    )


def win_sr(env):
    """
    On Windows, SYSTEMROOT must be present to avoid

    > Fatal Python error: _Py_HashRandomization_Init: failed to
    > get random numbers to initialize Python
    """
    if env is None:
        return
    if platform.system() == 'Windows':
        env['SYSTEMROOT'] = os.environ['SYSTEMROOT']
    return env


def find_distutils(venv, imports='distutils', env=None, **kwargs):
    py_cmd = 'import {imports}; print(distutils.__file__)'.format(**locals())
    cmd = ['python', '-c', py_cmd]
    return popen_text(venv.run)(cmd, env=win_sr(env), **kwargs)


def count_meta_path(venv, env=None):
    py_cmd = textwrap.dedent(
        """
        import sys
        is_distutils = lambda finder: finder.__class__.__name__ == "DistutilsMetaFinder"
        print(len(list(filter(is_distutils, sys.meta_path))))
        """
    )
    cmd = ['python', '-c', py_cmd]
    return int(popen_text(venv.run)(cmd, env=win_sr(env)))


skip_without_stdlib_distutils = pytest.mark.skipif(
    sys.version_info >= (3, 12),
    reason='stdlib distutils is removed from Python 3.12+',
)


@skip_without_stdlib_distutils
def test_distutils_stdlib(venv):
    """
    Ensure stdlib distutils is used when appropriate.
    """
    env = dict(SETUPTOOLS_USE_DISTUTILS='stdlib')
    assert venv.name not in find_distutils(venv, env=env).split(os.sep)
    assert count_meta_path(venv, env=env) == 0


def test_distutils_local_with_setuptools(venv):
    """
    Ensure local distutils is used when appropriate.
    """
    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
    loc = find_distutils(venv, imports='setuptools, distutils', env=env)
    assert venv.name in loc.split(os.sep)
    assert count_meta_path(venv, env=env) <= 1


@pytest.mark.xfail('IS_PYPY', reason='pypy imports distutils on startup')
def test_distutils_local(venv):
    """
    Even without importing, the setuptools-local copy of distutils is
    preferred.
    """
    env = dict(SETUPTOOLS_USE_DISTUTILS='local')
    assert venv.name in find_distutils(venv, env=env).split(os.sep)
    assert count_meta_path(venv, env=env) <= 1


def test_pip_import(venv):
    """
    Ensure pip can be imported.
    Regression test for #3002.
    """
    cmd = ['python', '-c', 'import pip']
    popen_text(venv.run)(cmd)


def test_distutils_has_origin():
    """
    Distutils module spec should have an origin. #2990.
    """
    assert __import__('distutils').__spec__.origin


ENSURE_IMPORTS_ARE_NOT_DUPLICATED = r"""
# Depending on the importlib machinery and _distutils_hack, some imports are
# duplicated resulting in different module objects being loaded, which prevents
# patches as shown in #3042.
# This script provides a way of verifying if this duplication is happening.

from distutils import cmd
import distutils.command.sdist as sdist

# import last to prevent caching
from distutils import {imported_module}

for mod in (cmd, sdist):
    assert mod.{imported_module} == {imported_module}, (
        f"\n{{mod.dir_util}}\n!=\n{{{imported_module}}}"
    )

print("success")
"""


@pytest.mark.parametrize(
    "distutils_version, imported_module",
    [
        pytest.param("stdlib", "dir_util", marks=skip_without_stdlib_distutils),
        pytest.param("stdlib", "file_util", marks=skip_without_stdlib_distutils),
        pytest.param("stdlib", "archive_util", marks=skip_without_stdlib_distutils),
        ("local", "dir_util"),
        ("local", "file_util"),
        ("local", "archive_util"),
    ],
)
def test_modules_are_not_duplicated_on_import(
    distutils_version, imported_module, tmpdir_cwd, venv
):
    env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version)
    script = ENSURE_IMPORTS_ARE_NOT_DUPLICATED.format(imported_module=imported_module)
    cmd = ['python', '-c', script]
    output = popen_text(venv.run)(cmd, env=win_sr(env)).strip()
    assert output == "success"


ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED = r"""
import types
import distutils.dist as dist
from distutils import log
if isinstance(dist.log, types.ModuleType):
    assert dist.log == log, f"\n{dist.log}\n!=\n{log}"
print("success")
"""


@pytest.mark.parametrize(
    "distutils_version",
    [
        "local",
        pytest.param("stdlib", marks=skip_without_stdlib_distutils),
    ],
)
def test_log_module_is_not_duplicated_on_import(distutils_version, tmpdir_cwd, venv):
    env = dict(SETUPTOOLS_USE_DISTUTILS=distutils_version)
    cmd = ['python', '-c', ENSURE_LOG_IMPORT_IS_NOT_DUPLICATED]
    output = popen_text(venv.run)(cmd, env=win_sr(env)).strip()
    assert output == "success"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_easy_install.py0000644000175100001730000014722414467657412023147 0ustar00runnerdocker"""Easy install Tests
"""

import sys
import os
import tempfile
import site
import contextlib
import tarfile
import logging
import itertools
import distutils.errors
import io
import zipfile
import time
import re
import subprocess
import pathlib
import warnings
from collections import namedtuple
from pathlib import Path
from unittest import mock

import pytest
from jaraco import path

from setuptools import sandbox
from setuptools.sandbox import run_setup
import setuptools.command.easy_install as ei
from setuptools.command.easy_install import PthDistributions
from setuptools.dist import Distribution
from pkg_resources import normalize_path, working_set
from pkg_resources import Distribution as PRDistribution
from setuptools.tests.server import MockServer, path_to_url
from setuptools.tests import fail_on_ascii
import pkg_resources

from . import contexts
from .textwrap import DALS


@pytest.fixture(autouse=True)
def pip_disable_index(monkeypatch):
    """
    Important: Disable the default index for pip to avoid
    querying packages in the index and potentially resolving
    and installing packages there.
    """
    monkeypatch.setenv('PIP_NO_INDEX', 'true')


class FakeDist:
    def get_entry_map(self, group):
        if group != 'console_scripts':
            return {}
        return {str('name'): 'ep'}

    def as_requirement(self):
        return 'spec'


SETUP_PY = DALS(
    """
    from setuptools import setup

    setup()
    """
)


class TestEasyInstallTest:
    def test_get_script_args(self):
        header = ei.CommandSpec.best().from_environment().as_header()
        dist = FakeDist()
        args = next(ei.ScriptWriter.get_args(dist))
        name, script = itertools.islice(args, 2)
        assert script.startswith(header)
        assert "'spec'" in script
        assert "'console_scripts'" in script
        assert "'name'" in script
        assert re.search('^# EASY-INSTALL-ENTRY-SCRIPT', script, flags=re.MULTILINE)

    def test_no_find_links(self):
        # new option '--no-find-links', that blocks find-links added at
        # the project level
        dist = Distribution()
        cmd = ei.easy_install(dist)
        cmd.check_pth_processing = lambda: True
        cmd.no_find_links = True
        cmd.find_links = ['link1', 'link2']
        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
        cmd.args = ['ok']
        cmd.ensure_finalized()
        assert cmd.package_index.scanned_urls == {}

        # let's try without it (default behavior)
        cmd = ei.easy_install(dist)
        cmd.check_pth_processing = lambda: True
        cmd.find_links = ['link1', 'link2']
        cmd.install_dir = os.path.join(tempfile.mkdtemp(), 'ok')
        cmd.args = ['ok']
        cmd.ensure_finalized()
        keys = sorted(cmd.package_index.scanned_urls.keys())
        assert keys == ['link1', 'link2']

    def test_write_exception(self):
        """
        Test that `cant_write_to_target` is rendered as a DistutilsError.
        """
        dist = Distribution()
        cmd = ei.easy_install(dist)
        cmd.install_dir = os.getcwd()
        with pytest.raises(distutils.errors.DistutilsError):
            cmd.cant_write_to_target()

    def test_all_site_dirs(self, monkeypatch):
        """
        get_site_dirs should always return site dirs reported by
        site.getsitepackages.
        """
        path = normalize_path('/setuptools/test/site-packages')

        def mock_gsp():
            return [path]

        monkeypatch.setattr(site, 'getsitepackages', mock_gsp, raising=False)
        assert path in ei.get_site_dirs()

    def test_all_site_dirs_works_without_getsitepackages(self, monkeypatch):
        monkeypatch.delattr(site, 'getsitepackages', raising=False)
        assert ei.get_site_dirs()

    @pytest.fixture
    def sdist_unicode(self, tmpdir):
        files = [
            (
                'setup.py',
                DALS(
                    """
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-unicode",
                        version="1.0",
                        packages=["mypkg"],
                        include_package_data=True,
                    )
                    """
                ),
            ),
            (
                'mypkg/__init__.py',
                "",
            ),
            (
                'mypkg/☃.txt',
                "",
            ),
        ]
        sdist_name = 'setuptools-test-unicode-1.0.zip'
        sdist = tmpdir / sdist_name
        # can't use make_sdist, because the issue only occurs
        #  with zip sdists.
        sdist_zip = zipfile.ZipFile(str(sdist), 'w')
        for filename, content in files:
            sdist_zip.writestr(filename, content)
        sdist_zip.close()
        return str(sdist)

    @fail_on_ascii
    def test_unicode_filename_in_sdist(self, sdist_unicode, tmpdir, monkeypatch):
        """
        The install command should execute correctly even if
        the package has unicode filenames.
        """
        dist = Distribution({'script_args': ['easy_install']})
        target = (tmpdir / 'target').ensure_dir()
        cmd = ei.easy_install(
            dist,
            install_dir=str(target),
            args=['x'],
        )
        monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target))
        cmd.ensure_finalized()
        cmd.easy_install(sdist_unicode)

    @pytest.fixture
    def sdist_unicode_in_script(self, tmpdir):
        files = [
            (
                "setup.py",
                DALS(
                    """
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-unicode",
                        version="1.0",
                        packages=["mypkg"],
                        include_package_data=True,
                        scripts=['mypkg/unicode_in_script'],
                    )
                    """
                ),
            ),
            ("mypkg/__init__.py", ""),
            (
                "mypkg/unicode_in_script",
                DALS(
                    """
                    #!/bin/sh
                    # á

                    non_python_fn() {
                    }
                """
                ),
            ),
        ]
        sdist_name = "setuptools-test-unicode-script-1.0.zip"
        sdist = tmpdir / sdist_name
        # can't use make_sdist, because the issue only occurs
        #  with zip sdists.
        sdist_zip = zipfile.ZipFile(str(sdist), "w")
        for filename, content in files:
            sdist_zip.writestr(filename, content.encode('utf-8'))
        sdist_zip.close()
        return str(sdist)

    @fail_on_ascii
    def test_unicode_content_in_sdist(
        self, sdist_unicode_in_script, tmpdir, monkeypatch
    ):
        """
        The install command should execute correctly even if
        the package has unicode in scripts.
        """
        dist = Distribution({"script_args": ["easy_install"]})
        target = (tmpdir / "target").ensure_dir()
        cmd = ei.easy_install(dist, install_dir=str(target), args=["x"])
        monkeypatch.setitem(os.environ, "PYTHONPATH", str(target))
        cmd.ensure_finalized()
        cmd.easy_install(sdist_unicode_in_script)

    @pytest.fixture
    def sdist_script(self, tmpdir):
        files = [
            (
                'setup.py',
                DALS(
                    """
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-script",
                        version="1.0",
                        scripts=["mypkg_script"],
                    )
                    """
                ),
            ),
            (
                'mypkg_script',
                DALS(
                    """
                     #/usr/bin/python
                     print('mypkg_script')
                     """
                ),
            ),
        ]
        sdist_name = 'setuptools-test-script-1.0.zip'
        sdist = str(tmpdir / sdist_name)
        make_sdist(sdist, files)
        return sdist

    @pytest.mark.skipif(
        not sys.platform.startswith('linux'), reason="Test can only be run on Linux"
    )
    def test_script_install(self, sdist_script, tmpdir, monkeypatch):
        """
        Check scripts are installed.
        """
        dist = Distribution({'script_args': ['easy_install']})
        target = (tmpdir / 'target').ensure_dir()
        cmd = ei.easy_install(
            dist,
            install_dir=str(target),
            args=['x'],
        )
        monkeypatch.setitem(os.environ, 'PYTHONPATH', str(target))
        cmd.ensure_finalized()
        cmd.easy_install(sdist_script)
        assert (target / 'mypkg_script').exists()


@pytest.mark.filterwarnings('ignore:Unbuilt egg')
class TestPTHFileWriter:
    def test_add_from_cwd_site_sets_dirty(self):
        '''a pth file manager should set dirty
        if a distribution is in site but also the cwd
        '''
        pth = PthDistributions('does-not_exist', [os.getcwd()])
        assert not pth.dirty
        pth.add(PRDistribution(os.getcwd()))
        assert pth.dirty

    def test_add_from_site_is_ignored(self):
        location = '/test/location/does-not-have-to-exist'
        # PthDistributions expects all locations to be normalized
        location = pkg_resources.normalize_path(location)
        pth = PthDistributions(
            'does-not_exist',
            [
                location,
            ],
        )
        assert not pth.dirty
        pth.add(PRDistribution(location))
        assert not pth.dirty

    def test_many_pth_distributions_merge_together(self, tmpdir):
        """
        If the pth file is modified under the hood, then PthDistribution
        will refresh its content before saving, merging contents when
        necessary.
        """
        # putting the pth file in a dedicated sub-folder,
        pth_subdir = tmpdir.join("pth_subdir")
        pth_subdir.mkdir()
        pth_path = str(pth_subdir.join("file1.pth"))
        pth1 = PthDistributions(pth_path)
        pth2 = PthDistributions(pth_path)
        assert (
            pth1.paths == pth2.paths == []
        ), "unless there would be some default added at some point"
        # and so putting the src_subdir in folder distinct than the pth one,
        # so to keep it absolute by PthDistributions
        new_src_path = tmpdir.join("src_subdir")
        new_src_path.mkdir()  # must exist to be accounted
        new_src_path_str = str(new_src_path)
        pth1.paths.append(new_src_path_str)
        pth1.save()
        assert (
            pth1.paths
        ), "the new_src_path added must still be present/valid in pth1 after save"
        # now,
        assert (
            new_src_path_str not in pth2.paths
        ), "right before we save the entry should still not be present"
        pth2.save()
        assert (
            new_src_path_str in pth2.paths
        ), "the new_src_path entry should have been added by pth2 with its save() call"
        assert pth2.paths[-1] == new_src_path, (
            "and it should match exactly on the last entry actually "
            "given we append to it in save()"
        )
        # finally,
        assert PthDistributions(pth_path).paths == pth2.paths, (
            "and we should have the exact same list at the end "
            "with a fresh PthDistributions instance"
        )


@pytest.fixture
def setup_context(tmpdir):
    with (tmpdir / 'setup.py').open('w') as f:
        f.write(SETUP_PY)
    with tmpdir.as_cwd():
        yield tmpdir


@pytest.mark.usefixtures("user_override")
@pytest.mark.usefixtures("setup_context")
class TestUserInstallTest:
    # prevent check that site-packages is writable. easy_install
    # shouldn't be writing to system site-packages during finalize
    # options, but while it does, bypass the behavior.
    prev_sp_write = mock.patch(
        'setuptools.command.easy_install.easy_install.check_site_dir',
        mock.Mock(),
    )

    # simulate setuptools installed in user site packages
    @mock.patch('setuptools.command.easy_install.__file__', site.USER_SITE)
    @mock.patch('site.ENABLE_USER_SITE', True)
    @prev_sp_write
    def test_user_install_not_implied_user_site_enabled(self):
        self.assert_not_user_site()

    @mock.patch('site.ENABLE_USER_SITE', False)
    @prev_sp_write
    def test_user_install_not_implied_user_site_disabled(self):
        self.assert_not_user_site()

    @staticmethod
    def assert_not_user_site():
        # create a finalized easy_install command
        dist = Distribution()
        dist.script_name = 'setup.py'
        cmd = ei.easy_install(dist)
        cmd.args = ['py']
        cmd.ensure_finalized()
        assert not cmd.user, 'user should not be implied'

    def test_multiproc_atexit(self):
        pytest.importorskip('multiprocessing')

        log = logging.getLogger('test_easy_install')
        logging.basicConfig(level=logging.INFO, stream=sys.stderr)
        log.info('this should not break')

    @pytest.fixture()
    def foo_package(self, tmpdir):
        egg_file = tmpdir / 'foo-1.0.egg-info'
        with egg_file.open('w') as f:
            f.write('Name: foo\n')
        return str(tmpdir)

    @pytest.fixture()
    def install_target(self, tmpdir):
        target = str(tmpdir)
        with mock.patch('sys.path', sys.path + [target]):
            python_path = os.path.pathsep.join(sys.path)
            with mock.patch.dict(os.environ, PYTHONPATH=python_path):
                yield target

    def test_local_index(self, foo_package, install_target):
        """
        The local index must be used when easy_install locates installed
        packages.
        """
        dist = Distribution()
        dist.script_name = 'setup.py'
        cmd = ei.easy_install(dist)
        cmd.install_dir = install_target
        cmd.args = ['foo']
        cmd.ensure_finalized()
        cmd.local_index.scan([foo_package])
        res = cmd.easy_install('foo')
        actual = os.path.normcase(os.path.realpath(res.location))
        expected = os.path.normcase(os.path.realpath(foo_package))
        assert actual == expected

    @contextlib.contextmanager
    def user_install_setup_context(self, *args, **kwargs):
        """
        Wrap sandbox.setup_context to patch easy_install in that context to
        appear as user-installed.
        """
        with self.orig_context(*args, **kwargs):
            import setuptools.command.easy_install as ei

            ei.__file__ = site.USER_SITE
            yield

    def patched_setup_context(self):
        self.orig_context = sandbox.setup_context

        return mock.patch(
            'setuptools.sandbox.setup_context',
            self.user_install_setup_context,
        )


@pytest.fixture
def distutils_package():
    distutils_setup_py = SETUP_PY.replace(
        'from setuptools import setup',
        'from distutils.core import setup',
    )
    with contexts.tempdir(cd=os.chdir):
        with open('setup.py', 'w') as f:
            f.write(distutils_setup_py)
        yield


@pytest.fixture
def mock_index():
    # set up a server which will simulate an alternate package index.
    p_index = MockServer()
    if p_index.server_port == 0:
        # Some platforms (Jython) don't find a port to which to bind,
        # so skip test for them.
        pytest.skip("could not find a valid port")
    p_index.start()
    return p_index


class TestDistutilsPackage:
    def test_bdist_egg_available_on_distutils_pkg(self, distutils_package):
        run_setup('setup.py', ['bdist_egg'])


class TestInstallRequires:
    def test_setup_install_includes_dependencies(self, tmp_path, mock_index):
        """
        When ``python setup.py install`` is called directly, it will use easy_install
        to fetch dependencies.
        """
        # TODO: Remove these tests once `setup.py install` is completely removed
        project_root = tmp_path / "project"
        project_root.mkdir(exist_ok=True)
        install_root = tmp_path / "install"
        install_root.mkdir(exist_ok=True)

        self.create_project(project_root)
        cmd = [
            sys.executable,
            '-c',
            '__import__("setuptools").setup()',
            'install',
            '--install-base',
            str(install_root),
            '--install-lib',
            str(install_root),
            '--install-headers',
            str(install_root),
            '--install-scripts',
            str(install_root),
            '--install-data',
            str(install_root),
            '--install-purelib',
            str(install_root),
            '--install-platlib',
            str(install_root),
        ]
        env = {**os.environ, "__EASYINSTALL_INDEX": mock_index.url}
        cp = subprocess.run(
            cmd,
            cwd=str(project_root),
            env=env,
            stdout=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
        )
        assert cp.returncode != 0
        try:
            assert '/does-not-exist/' in {r.path for r in mock_index.requests}
            assert next(
                line
                for line in cp.stdout.splitlines()
                if "not find suitable distribution for" in line
                and "does-not-exist" in line
            )
        except Exception:
            if "failed to get random numbers" in cp.stdout:
                pytest.xfail(f"{sys.platform} failure - {cp.stdout}")
            raise

    def create_project(self, root):
        config = """
        [metadata]
        name = project
        version = 42

        [options]
        install_requires = does-not-exist
        py_modules = mod
        """
        (root / 'setup.cfg').write_text(DALS(config), encoding="utf-8")
        (root / 'mod.py').touch()


class TestSetupRequires:
    def test_setup_requires_honors_fetch_params(self, mock_index, monkeypatch):
        """
        When easy_install installs a source distribution which specifies
        setup_requires, it should honor the fetch parameters (such as
        index-url, and find-links).
        """
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv('PIP_NO_INDEX', 'false')
        with contexts.quiet():
            # create an sdist that has a build-time dependency.
            with TestSetupRequires.create_sdist() as dist_file:
                with contexts.tempdir() as temp_install_dir:
                    with contexts.environment(PYTHONPATH=temp_install_dir):
                        cmd = [
                            sys.executable,
                            '-c',
                            '__import__("setuptools").setup()',
                            'easy_install',
                            '--index-url',
                            mock_index.url,
                            '--exclude-scripts',
                            '--install-dir',
                            temp_install_dir,
                            dist_file,
                        ]
                        subprocess.Popen(cmd).wait()
        # there should have been one requests to the server
        assert [r.path for r in mock_index.requests] == ['/does-not-exist/']

    @staticmethod
    @contextlib.contextmanager
    def create_sdist():
        """
        Return an sdist with a setup_requires dependency (of something that
        doesn't exist)
        """
        with contexts.tempdir() as dir:
            dist_path = os.path.join(dir, 'setuptools-test-fetcher-1.0.tar.gz')
            make_sdist(
                dist_path,
                [
                    (
                        'setup.py',
                        DALS(
                            """
                    import setuptools
                    setuptools.setup(
                        name="setuptools-test-fetcher",
                        version="1.0",
                        setup_requires = ['does-not-exist'],
                    )
                """
                        ),
                    ),
                    ('setup.cfg', ''),
                ],
            )
            yield dist_path

    use_setup_cfg = (
        (),
        ('dependency_links',),
        ('setup_requires',),
        ('dependency_links', 'setup_requires'),
    )

    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
    def test_setup_requires_overrides_version_conflict(self, use_setup_cfg):
        """
        Regression test for distribution issue 323:
        https://bitbucket.org/tarek/distribute/issues/323

        Ensures that a distribution's setup_requires requirements can still be
        installed and used locally even if a conflicting version of that
        requirement is already on the path.
        """

        fake_dist = PRDistribution(
            'does-not-matter', project_name='foobar', version='0.0'
        )
        working_set.add(fake_dist)

        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                test_pkg = create_setup_requires_package(
                    temp_dir, use_setup_cfg=use_setup_cfg
                )
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                with contexts.quiet() as (stdout, stderr):
                    # Don't even need to install the package, just
                    # running the setup.py at all is sufficient
                    run_setup(test_setup_py, [str('--name')])

                lines = stdout.readlines()
                assert len(lines) > 0
                assert lines[-1].strip() == 'test_pkg'

    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
    def test_setup_requires_override_nspkg(self, use_setup_cfg):
        """
        Like ``test_setup_requires_overrides_version_conflict`` but where the
        ``setup_requires`` package is part of a namespace package that has
        *already* been imported.
        """

        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                foobar_1_archive = os.path.join(temp_dir, 'foo.bar-0.1.tar.gz')
                make_nspkg_sdist(foobar_1_archive, 'foo.bar', '0.1')
                # Now actually go ahead an extract to the temp dir and add the
                # extracted path to sys.path so foo.bar v0.1 is importable
                foobar_1_dir = os.path.join(temp_dir, 'foo.bar-0.1')
                os.mkdir(foobar_1_dir)
                with tarfile.open(foobar_1_archive) as tf:
                    tf.extraction_filter = lambda member, path: member
                    tf.extractall(foobar_1_dir)
                sys.path.insert(1, foobar_1_dir)

                dist = PRDistribution(
                    foobar_1_dir, project_name='foo.bar', version='0.1'
                )
                working_set.add(dist)

                template = DALS(
                    """\
                    import foo  # Even with foo imported first the
                                # setup_requires package should override
                    import setuptools
                    setuptools.setup(**%r)

                    if not (hasattr(foo, '__path__') and
                            len(foo.__path__) == 2):
                        print('FAIL')

                    if 'foo.bar-0.2' not in foo.__path__[0]:
                        print('FAIL')
                """
                )

                test_pkg = create_setup_requires_package(
                    temp_dir,
                    'foo.bar',
                    '0.2',
                    make_nspkg_sdist,
                    template,
                    use_setup_cfg=use_setup_cfg,
                )

                test_setup_py = os.path.join(test_pkg, 'setup.py')

                with contexts.quiet() as (stdout, stderr):
                    try:
                        # Don't even need to install the package, just
                        # running the setup.py at all is sufficient
                        run_setup(test_setup_py, [str('--name')])
                    except pkg_resources.VersionConflict:
                        self.fail(
                            'Installing setup.py requirements '
                            'caused a VersionConflict'
                        )

                assert 'FAIL' not in stdout.getvalue()
                lines = stdout.readlines()
                assert len(lines) > 0
                assert lines[-1].strip() == 'test_pkg'

    @pytest.mark.parametrize('use_setup_cfg', use_setup_cfg)
    def test_setup_requires_with_attr_version(self, use_setup_cfg):
        def make_dependency_sdist(dist_path, distname, version):
            files = [
                (
                    'setup.py',
                    DALS(
                        """
                    import setuptools
                    setuptools.setup(
                        name={name!r},
                        version={version!r},
                        py_modules=[{name!r}],
                    )
                    """.format(
                            name=distname, version=version
                        )
                    ),
                ),
                (
                    distname + '.py',
                    DALS(
                        """
                    version = 42
                    """
                    ),
                ),
            ]
            make_sdist(dist_path, files)

        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                test_pkg = create_setup_requires_package(
                    temp_dir,
                    setup_attrs=dict(version='attr: foobar.version'),
                    make_package=make_dependency_sdist,
                    use_setup_cfg=use_setup_cfg + ('version',),
                )
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                with contexts.quiet() as (stdout, stderr):
                    run_setup(test_setup_py, [str('--version')])
                lines = stdout.readlines()
                assert len(lines) > 0
                assert lines[-1].strip() == '42'

    def test_setup_requires_honors_pip_env(self, mock_index, monkeypatch):
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv('PIP_NO_INDEX', 'false')
        monkeypatch.setenv(str('PIP_INDEX_URL'), mock_index.url)
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                test_pkg = create_setup_requires_package(
                    temp_dir,
                    'python-xlib',
                    '0.19',
                    setup_attrs=dict(dependency_links=[]),
                )
                test_setup_cfg = os.path.join(test_pkg, 'setup.cfg')
                with open(test_setup_cfg, 'w') as fp:
                    fp.write(
                        DALS(
                            '''
                        [easy_install]
                        index_url = https://pypi.org/legacy/
                        '''
                        )
                    )
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                with pytest.raises(distutils.errors.DistutilsError):
                    run_setup(test_setup_py, [str('--version')])
        assert len(mock_index.requests) == 1
        assert mock_index.requests[0].path == '/python-xlib/'

    def test_setup_requires_with_pep508_url(self, mock_index, monkeypatch):
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv(str('PIP_INDEX_URL'), mock_index.url)
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                dep_sdist = os.path.join(temp_dir, 'dep.tar.gz')
                make_trivial_sdist(dep_sdist, 'dependency', '42')
                dep_url = path_to_url(dep_sdist, authority='localhost')
                test_pkg = create_setup_requires_package(
                    temp_dir,
                    # Ignored (overridden by setup_attrs)
                    'python-xlib',
                    '0.19',
                    setup_attrs=dict(setup_requires='dependency @ %s' % dep_url),
                )
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                run_setup(test_setup_py, [str('--version')])
        assert len(mock_index.requests) == 0

    def test_setup_requires_with_allow_hosts(self, mock_index):
        '''The `allow-hosts` option in not supported anymore.'''
        files = {
            'test_pkg': {
                'setup.py': DALS(
                    '''
                    from setuptools import setup
                    setup(setup_requires='python-xlib')
                    '''
                ),
                'setup.cfg': DALS(
                    '''
                    [easy_install]
                    allow_hosts = *
                    '''
                ),
            }
        }
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                path.build(files, prefix=temp_dir)
                setup_py = str(pathlib.Path(temp_dir, 'test_pkg', 'setup.py'))
                with pytest.raises(distutils.errors.DistutilsError):
                    run_setup(setup_py, [str('--version')])
        assert len(mock_index.requests) == 0

    def test_setup_requires_with_python_requires(self, monkeypatch, tmpdir):
        '''Check `python_requires` is honored.'''
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        monkeypatch.setenv(str('PIP_NO_INDEX'), str('1'))
        monkeypatch.setenv(str('PIP_VERBOSE'), str('1'))
        dep_1_0_sdist = 'dep-1.0.tar.gz'
        dep_1_0_url = path_to_url(str(tmpdir / dep_1_0_sdist))
        dep_1_0_python_requires = '>=2.7'
        make_python_requires_sdist(
            str(tmpdir / dep_1_0_sdist), 'dep', '1.0', dep_1_0_python_requires
        )
        dep_2_0_sdist = 'dep-2.0.tar.gz'
        dep_2_0_url = path_to_url(str(tmpdir / dep_2_0_sdist))
        dep_2_0_python_requires = '!=' + '.'.join(map(str, sys.version_info[:2])) + '.*'
        make_python_requires_sdist(
            str(tmpdir / dep_2_0_sdist), 'dep', '2.0', dep_2_0_python_requires
        )
        index = tmpdir / 'index.html'
        index.write_text(
            DALS(
                '''
            
            Links for dep
            
                
Links for dep

                {dep_1_0_sdist}

                {dep_2_0_sdist}

            
            
            '''
            ).format(
                dep_1_0_url=dep_1_0_url,
                dep_1_0_sdist=dep_1_0_sdist,
                dep_1_0_python_requires=dep_1_0_python_requires,
                dep_2_0_url=dep_2_0_url,
                dep_2_0_sdist=dep_2_0_sdist,
                dep_2_0_python_requires=dep_2_0_python_requires,
            ),
            'utf-8',
        )
        index_url = path_to_url(str(index))
        with contexts.save_pkg_resources_state():
            test_pkg = create_setup_requires_package(
                str(tmpdir),
                'python-xlib',
                '0.19',  # Ignored (overridden by setup_attrs).
                setup_attrs=dict(setup_requires='dep', dependency_links=[index_url]),
            )
            test_setup_py = os.path.join(test_pkg, 'setup.py')
            run_setup(test_setup_py, [str('--version')])
        eggs = list(
            map(str, pkg_resources.find_distributions(os.path.join(test_pkg, '.eggs')))
        )
        assert eggs == ['dep 1.0']

    @pytest.mark.parametrize('with_dependency_links_in_setup_py', (False, True))
    def test_setup_requires_with_find_links_in_setup_cfg(
        self, monkeypatch, with_dependency_links_in_setup_py
    ):
        monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
        monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                make_trivial_sdist(
                    os.path.join(temp_dir, 'python-xlib-42.tar.gz'), 'python-xlib', '42'
                )
                test_pkg = os.path.join(temp_dir, 'test_pkg')
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                test_setup_cfg = os.path.join(test_pkg, 'setup.cfg')
                os.mkdir(test_pkg)
                with open(test_setup_py, 'w') as fp:
                    if with_dependency_links_in_setup_py:
                        dependency_links = [os.path.join(temp_dir, 'links')]
                    else:
                        dependency_links = []
                    fp.write(
                        DALS(
                            '''
                        from setuptools import installer, setup
                        setup(setup_requires='python-xlib==42',
                        dependency_links={dependency_links!r})
                        '''
                        ).format(dependency_links=dependency_links)
                    )
                with open(test_setup_cfg, 'w') as fp:
                    fp.write(
                        DALS(
                            '''
                        [easy_install]
                        index_url = {index_url}
                        find_links = {find_links}
                        '''
                        ).format(
                            index_url=os.path.join(temp_dir, 'index'),
                            find_links=temp_dir,
                        )
                    )
                run_setup(test_setup_py, [str('--version')])

    def test_setup_requires_with_transitive_extra_dependency(self, monkeypatch):
        '''
        Use case: installing a package with a build dependency on
        an already installed `dep[extra]`, which in turn depends
        on `extra_dep` (whose is not already installed).
        '''
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                # Create source distribution for `extra_dep`.
                make_trivial_sdist(
                    os.path.join(temp_dir, 'extra_dep-1.0.tar.gz'), 'extra_dep', '1.0'
                )
                # Create source tree for `dep`.
                dep_pkg = os.path.join(temp_dir, 'dep')
                os.mkdir(dep_pkg)
                path.build(
                    {
                        'setup.py': DALS(
                            """
                          import setuptools
                          setuptools.setup(
                              name='dep', version='2.0',
                              extras_require={'extra': ['extra_dep']},
                          )
                         """
                        ),
                        'setup.cfg': '',
                    },
                    prefix=dep_pkg,
                )
                # "Install" dep.
                run_setup(os.path.join(dep_pkg, 'setup.py'), [str('dist_info')])
                working_set.add_entry(dep_pkg)
                # Create source tree for test package.
                test_pkg = os.path.join(temp_dir, 'test_pkg')
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                os.mkdir(test_pkg)
                with open(test_setup_py, 'w') as fp:
                    fp.write(
                        DALS(
                            '''
                        from setuptools import installer, setup
                        setup(setup_requires='dep[extra]')
                        '''
                        )
                    )
                # Check...
                monkeypatch.setenv(str('PIP_FIND_LINKS'), str(temp_dir))
                monkeypatch.setenv(str('PIP_NO_INDEX'), str('1'))
                monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
                monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
                run_setup(test_setup_py, [str('--version')])

    def test_setup_requires_with_distutils_command_dep(self, monkeypatch):
        '''
        Use case: ensure build requirements' extras
        are properly installed and activated.
        '''
        with contexts.save_pkg_resources_state():
            with contexts.tempdir() as temp_dir:
                # Create source distribution for `extra_dep`.
                make_sdist(
                    os.path.join(temp_dir, 'extra_dep-1.0.tar.gz'),
                    [
                        (
                            'setup.py',
                            DALS(
                                """
                          import setuptools
                          setuptools.setup(
                              name='extra_dep',
                              version='1.0',
                              py_modules=['extra_dep'],
                          )
                          """
                            ),
                        ),
                        ('setup.cfg', ''),
                        ('extra_dep.py', ''),
                    ],
                )
                # Create source tree for `epdep`.
                dep_pkg = os.path.join(temp_dir, 'epdep')
                os.mkdir(dep_pkg)
                path.build(
                    {
                        'setup.py': DALS(
                            """
                          import setuptools
                          setuptools.setup(
                              name='dep', version='2.0',
                              py_modules=['epcmd'],
                              extras_require={'extra': ['extra_dep']},
                              entry_points='''
                                           [distutils.commands]
                                           epcmd = epcmd:epcmd [extra]
                                           ''',
                          )
                         """
                        ),
                        'setup.cfg': '',
                        'epcmd.py': DALS(
                            """
                                     from distutils.command.build_py import build_py

                                     import extra_dep

                                     class epcmd(build_py):
                                         pass
                                     """
                        ),
                    },
                    prefix=dep_pkg,
                )
                # "Install" dep.
                run_setup(os.path.join(dep_pkg, 'setup.py'), [str('dist_info')])
                working_set.add_entry(dep_pkg)
                # Create source tree for test package.
                test_pkg = os.path.join(temp_dir, 'test_pkg')
                test_setup_py = os.path.join(test_pkg, 'setup.py')
                os.mkdir(test_pkg)
                with open(test_setup_py, 'w') as fp:
                    fp.write(
                        DALS(
                            '''
                        from setuptools import installer, setup
                        setup(setup_requires='dep[extra]')
                        '''
                        )
                    )
                # Check...
                monkeypatch.setenv(str('PIP_FIND_LINKS'), str(temp_dir))
                monkeypatch.setenv(str('PIP_NO_INDEX'), str('1'))
                monkeypatch.setenv(str('PIP_RETRIES'), str('0'))
                monkeypatch.setenv(str('PIP_TIMEOUT'), str('0'))
                run_setup(test_setup_py, ['epcmd'])


def make_trivial_sdist(dist_path, distname, version):
    """
    Create a simple sdist tarball at dist_path, containing just a simple
    setup.py.
    """

    make_sdist(
        dist_path,
        [
            (
                'setup.py',
                DALS(
                    """\
             import setuptools
             setuptools.setup(
                 name=%r,
                 version=%r
             )
         """
                    % (distname, version)
                ),
            ),
            ('setup.cfg', ''),
        ],
    )


def make_nspkg_sdist(dist_path, distname, version):
    """
    Make an sdist tarball with distname and version which also contains one
    package with the same name as distname.  The top-level package is
    designated a namespace package).
    """

    parts = distname.split('.')
    nspackage = parts[0]

    packages = ['.'.join(parts[:idx]) for idx in range(1, len(parts) + 1)]

    setup_py = DALS(
        """\
        import setuptools
        setuptools.setup(
            name=%r,
            version=%r,
            packages=%r,
            namespace_packages=[%r]
        )
    """
        % (distname, version, packages, nspackage)
    )

    init = "__import__('pkg_resources').declare_namespace(__name__)"

    files = [('setup.py', setup_py), (os.path.join(nspackage, '__init__.py'), init)]
    for package in packages[1:]:
        filename = os.path.join(*(package.split('.') + ['__init__.py']))
        files.append((filename, ''))

    make_sdist(dist_path, files)


def make_python_requires_sdist(dist_path, distname, version, python_requires):
    make_sdist(
        dist_path,
        [
            (
                'setup.py',
                DALS(
                    """\
                import setuptools
                setuptools.setup(
                  name={name!r},
                  version={version!r},
                  python_requires={python_requires!r},
                )
                """
                ).format(
                    name=distname, version=version, python_requires=python_requires
                ),
            ),
            ('setup.cfg', ''),
        ],
    )


def make_sdist(dist_path, files):
    """
    Create a simple sdist tarball at dist_path, containing the files
    listed in ``files`` as ``(filename, content)`` tuples.
    """

    # Distributions with only one file don't play well with pip.
    assert len(files) > 1
    with tarfile.open(dist_path, 'w:gz') as dist:
        for filename, content in files:
            file_bytes = io.BytesIO(content.encode('utf-8'))
            file_info = tarfile.TarInfo(name=filename)
            file_info.size = len(file_bytes.getvalue())
            file_info.mtime = int(time.time())
            dist.addfile(file_info, fileobj=file_bytes)


def create_setup_requires_package(
    path,
    distname='foobar',
    version='0.1',
    make_package=make_trivial_sdist,
    setup_py_template=None,
    setup_attrs={},
    use_setup_cfg=(),
):
    """Creates a source tree under path for a trivial test package that has a
    single requirement in setup_requires--a tarball for that requirement is
    also created and added to the dependency_links argument.

    ``distname`` and ``version`` refer to the name/version of the package that
    the test package requires via ``setup_requires``.  The name of the test
    package itself is just 'test_pkg'.
    """

    test_setup_attrs = {
        'name': 'test_pkg',
        'version': '0.0',
        'setup_requires': ['%s==%s' % (distname, version)],
        'dependency_links': [os.path.abspath(path)],
    }
    test_setup_attrs.update(setup_attrs)

    test_pkg = os.path.join(path, 'test_pkg')
    os.mkdir(test_pkg)

    # setup.cfg
    if use_setup_cfg:
        options = []
        metadata = []
        for name in use_setup_cfg:
            value = test_setup_attrs.pop(name)
            if name in 'name version'.split():
                section = metadata
            else:
                section = options
            if isinstance(value, (tuple, list)):
                value = ';'.join(value)
            section.append('%s: %s' % (name, value))
        test_setup_cfg_contents = DALS(
            """
            [metadata]
            {metadata}
            [options]
            {options}
            """
        ).format(
            options='\n'.join(options),
            metadata='\n'.join(metadata),
        )
    else:
        test_setup_cfg_contents = ''
    with open(os.path.join(test_pkg, 'setup.cfg'), 'w') as f:
        f.write(test_setup_cfg_contents)

    # setup.py
    if setup_py_template is None:
        setup_py_template = DALS(
            """\
            import setuptools
            setuptools.setup(**%r)
        """
        )
    with open(os.path.join(test_pkg, 'setup.py'), 'w') as f:
        f.write(setup_py_template % test_setup_attrs)

    foobar_path = os.path.join(path, '%s-%s.tar.gz' % (distname, version))
    make_package(foobar_path, distname, version)

    return test_pkg


@pytest.mark.skipif(
    sys.platform.startswith('java') and ei.is_sh(sys.executable),
    reason="Test cannot run under java when executable is sh",
)
class TestScriptHeader:
    non_ascii_exe = '/Users/José/bin/python'
    exe_with_spaces = r'C:\Program Files\Python36\python.exe'

    def test_get_script_header(self):
        expected = '#!%s\n' % ei.nt_quote_arg(os.path.normpath(sys.executable))
        actual = ei.ScriptWriter.get_header('#!/usr/local/bin/python')
        assert actual == expected

    def test_get_script_header_args(self):
        expected = '#!%s -x\n' % ei.nt_quote_arg(os.path.normpath(sys.executable))
        actual = ei.ScriptWriter.get_header('#!/usr/bin/python -x')
        assert actual == expected

    def test_get_script_header_non_ascii_exe(self):
        actual = ei.ScriptWriter.get_header(
            '#!/usr/bin/python', executable=self.non_ascii_exe
        )
        expected = str('#!%s -x\n') % self.non_ascii_exe
        assert actual == expected

    def test_get_script_header_exe_with_spaces(self):
        actual = ei.ScriptWriter.get_header(
            '#!/usr/bin/python', executable='"' + self.exe_with_spaces + '"'
        )
        expected = '#!"%s"\n' % self.exe_with_spaces
        assert actual == expected


class TestCommandSpec:
    def test_custom_launch_command(self):
        """
        Show how a custom CommandSpec could be used to specify a #! executable
        which takes parameters.
        """
        cmd = ei.CommandSpec(['/usr/bin/env', 'python3'])
        assert cmd.as_header() == '#!/usr/bin/env python3\n'

    def test_from_param_for_CommandSpec_is_passthrough(self):
        """
        from_param should return an instance of a CommandSpec
        """
        cmd = ei.CommandSpec(['python'])
        cmd_new = ei.CommandSpec.from_param(cmd)
        assert cmd is cmd_new

    @mock.patch('sys.executable', TestScriptHeader.exe_with_spaces)
    @mock.patch.dict(os.environ)
    def test_from_environment_with_spaces_in_executable(self):
        os.environ.pop('__PYVENV_LAUNCHER__', None)
        cmd = ei.CommandSpec.from_environment()
        assert len(cmd) == 1
        assert cmd.as_header().startswith('#!"')

    def test_from_simple_string_uses_shlex(self):
        """
        In order to support `executable = /usr/bin/env my-python`, make sure
        from_param invokes shlex on that input.
        """
        cmd = ei.CommandSpec.from_param('/usr/bin/env my-python')
        assert len(cmd) == 2
        assert '"' not in cmd.as_header()


class TestWindowsScriptWriter:
    def test_header(self):
        hdr = ei.WindowsScriptWriter.get_header('')
        assert hdr.startswith('#!')
        assert hdr.endswith('\n')
        hdr = hdr.lstrip('#!')
        hdr = hdr.rstrip('\n')
        # header should not start with an escaped quote
        assert not hdr.startswith('\\"')


VersionStub = namedtuple("VersionStub", "major, minor, micro, releaselevel, serial")


def test_use_correct_python_version_string(tmpdir, tmpdir_cwd, monkeypatch):
    # In issue #3001, easy_install wrongly uses the `python3.1` directory
    # when the interpreter is `python3.10` and the `--user` option is given.
    # See pypa/setuptools#3001.
    dist = Distribution()
    cmd = dist.get_command_obj('easy_install')
    cmd.args = ['ok']
    cmd.optimize = 0
    cmd.user = True
    cmd.install_userbase = str(tmpdir)
    cmd.install_usersite = None
    install_cmd = dist.get_command_obj('install')
    install_cmd.install_userbase = str(tmpdir)
    install_cmd.install_usersite = None

    with monkeypatch.context() as patch, warnings.catch_warnings():
        warnings.simplefilter("ignore")
        version = '3.10.1 (main, Dec 21 2021, 09:17:12) [GCC 10.2.1 20210110]'
        info = VersionStub(3, 10, 1, "final", 0)
        patch.setattr('site.ENABLE_USER_SITE', True)
        patch.setattr('sys.version', version)
        patch.setattr('sys.version_info', info)
        patch.setattr(cmd, 'create_home_path', mock.Mock())
        cmd.finalize_options()

    name = "pypy" if hasattr(sys, 'pypy_version_info') else "python"
    install_dir = cmd.install_dir.lower()

    # In some platforms (e.g. Windows), install_dir is mostly determined
    # via `sysconfig`, which define constants eagerly at module creation.
    # This means that monkeypatching `sys.version` to emulate 3.10 for testing
    # may have no effect.
    # The safest test here is to rely on the fact that 3.1 is no longer
    # supported/tested, and make sure that if 'python3.1' ever appears in the string
    # it is followed by another digit (e.g. 'python3.10').
    if re.search(name + r'3\.?1', install_dir):
        assert re.search(name + r'3\.?1\d', install_dir)

    # The following "variables" are used for interpolation in distutils
    # installation schemes, so it should be fair to treat them as "semi-public",
    # or at least public enough so we can have a test to make sure they are correct
    assert cmd.config_vars['py_version'] == '3.10.1'
    assert cmd.config_vars['py_version_short'] == '3.10'
    assert cmd.config_vars['py_version_nodot'] == '310'


def test_editable_user_and_build_isolation(setup_context, monkeypatch, tmp_path):
    '''`setup.py develop` should honor `--user` even under build isolation'''

    # == Arrange ==
    # Pretend that build isolation was enabled
    # e.g pip sets the environment variable PYTHONNOUSERSITE=1
    monkeypatch.setattr('site.ENABLE_USER_SITE', False)

    # Patching $HOME for 2 reasons:
    # 1. setuptools/command/easy_install.py:create_home_path
    #    tries creating directories in $HOME.
    #    Given::
    #        self.config_vars['DESTDIRS'] = (
    #            "/home/user/.pyenv/versions/3.9.10 "
    #            "/home/user/.pyenv/versions/3.9.10/lib "
    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9 "
    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9/lib-dynload")
    #    `create_home_path` will::
    #        makedirs(
    #            "/home/user/.pyenv/versions/3.9.10 "
    #            "/home/user/.pyenv/versions/3.9.10/lib "
    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9 "
    #            "/home/user/.pyenv/versions/3.9.10/lib/python3.9/lib-dynload")
    #
    # 2. We are going to force `site` to update site.USER_BASE and site.USER_SITE
    #    To point inside our new home
    monkeypatch.setenv('HOME', str(tmp_path / '.home'))
    monkeypatch.setenv('USERPROFILE', str(tmp_path / '.home'))
    monkeypatch.setenv('APPDATA', str(tmp_path / '.home'))
    monkeypatch.setattr('site.USER_BASE', None)
    monkeypatch.setattr('site.USER_SITE', None)
    user_site = Path(site.getusersitepackages())
    user_site.mkdir(parents=True, exist_ok=True)

    sys_prefix = tmp_path / '.sys_prefix'
    sys_prefix.mkdir(parents=True, exist_ok=True)
    monkeypatch.setattr('sys.prefix', str(sys_prefix))

    setup_script = (
        "__import__('setuptools').setup(name='aproj', version=42, packages=[])\n"
    )
    (tmp_path / "setup.py").write_text(setup_script, encoding="utf-8")

    # == Sanity check ==
    assert list(sys_prefix.glob("*")) == []
    assert list(user_site.glob("*")) == []

    # == Act ==
    run_setup('setup.py', ['develop', '--user'])

    # == Assert ==
    # Should not install to sys.prefix
    assert list(sys_prefix.glob("*")) == []
    # Should install to user site
    installed = {f.name for f in user_site.glob("*")}
    # sometimes easy-install.pth is created and sometimes not
    installed = installed - {"easy-install.pth"}
    assert installed == {'aproj.egg-link'}
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_editable_install.py0000644000175100001730000011715114467657412023753 0ustar00runnerdockerimport os
import stat
import sys
import subprocess
import platform
from copy import deepcopy
from importlib import import_module
from importlib.machinery import EXTENSION_SUFFIXES
from pathlib import Path
from textwrap import dedent
from unittest.mock import Mock
from uuid import uuid4

import jaraco.envs
import jaraco.path
import pytest
from path import Path as _Path

from . import contexts, namespaces

from setuptools._importlib import resources as importlib_resources
from setuptools.command.editable_wheel import (
    _DebuggingTips,
    _LinkTree,
    _encode_pth,
    _find_virtual_namespaces,
    _find_namespaces,
    _find_package_roots,
    _finder_template,
    editable_wheel,
)
from setuptools.dist import Distribution
from setuptools.extension import Extension


@pytest.fixture(params=["strict", "lenient"])
def editable_opts(request):
    if request.param == "strict":
        return ["--config-settings", "editable-mode=strict"]
    return []


EXAMPLE = {
    'pyproject.toml': dedent(
        """\
        [build-system]
        requires = ["setuptools"]
        build-backend = "setuptools.build_meta"

        [project]
        name = "mypkg"
        version = "3.14159"
        license = {text = "MIT"}
        description = "This is a Python package"
        dynamic = ["readme"]
        classifiers = [
            "Development Status :: 5 - Production/Stable",
            "Intended Audience :: Developers"
        ]
        urls = {Homepage = "http://github.com"}
        dependencies = ['importlib-metadata; python_version<"3.8"']

        [tool.setuptools]
        package-dir = {"" = "src"}
        packages = {find = {where = ["src"]}}
        license-files = ["LICENSE*"]

        [tool.setuptools.dynamic]
        readme = {file = "README.rst"}

        [tool.distutils.egg_info]
        tag-build = ".post0"
        """
    ),
    "MANIFEST.in": dedent(
        """\
        global-include *.py *.txt
        global-exclude *.py[cod]
        prune dist
        prune build
        """
    ).strip(),
    "README.rst": "This is a ``README``",
    "LICENSE.txt": "---- placeholder MIT license ----",
    "src": {
        "mypkg": {
            "__init__.py": dedent(
                """\
                import sys

                if sys.version_info[:2] >= (3, 8):
                    from importlib.metadata import PackageNotFoundError, version
                else:
                    from importlib_metadata import PackageNotFoundError, version

                try:
                    __version__ = version(__name__)
                except PackageNotFoundError:
                    __version__ = "unknown"
                """
            ),
            "__main__.py": dedent(
                """\
                from importlib.resources import read_text
                from . import __version__, __name__ as parent
                from .mod import x

                data = read_text(parent, "data.txt")
                print(__version__, data, x)
                """
            ),
            "mod.py": "x = ''",
            "data.txt": "Hello World",
        }
    },
}


SETUP_SCRIPT_STUB = "__import__('setuptools').setup()"


@pytest.mark.parametrize(
    "files",
    [
        {**EXAMPLE, "setup.py": SETUP_SCRIPT_STUB},  # type: ignore
        EXAMPLE,  # No setup.py script
    ],
)
def test_editable_with_pyproject(tmp_path, venv, files, editable_opts):
    project = tmp_path / "mypkg"
    project.mkdir()
    jaraco.path.build(files, prefix=project)

    cmd = [
        venv.exe(),
        "-m",
        "pip",
        "install",
        "--no-build-isolation",  # required to force current version of setuptools
        "-e",
        str(project),
        *editable_opts,
    ]
    print(str(subprocess.check_output(cmd), "utf-8"))

    cmd = [venv.exe(), "-m", "mypkg"]
    assert subprocess.check_output(cmd).strip() == b"3.14159.post0 Hello World"

    (project / "src/mypkg/data.txt").write_text("foobar")
    (project / "src/mypkg/mod.py").write_text("x = 42")
    assert subprocess.check_output(cmd).strip() == b"3.14159.post0 foobar 42"


def test_editable_with_flat_layout(tmp_path, venv, editable_opts):
    files = {
        "mypkg": {
            "pyproject.toml": dedent(
                """\
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"

                [project]
                name = "mypkg"
                version = "3.14159"

                [tool.setuptools]
                packages = ["pkg"]
                py-modules = ["mod"]
                """
            ),
            "pkg": {"__init__.py": "a = 4"},
            "mod.py": "b = 2",
        },
    }
    jaraco.path.build(files, prefix=tmp_path)
    project = tmp_path / "mypkg"

    cmd = [
        venv.exe(),
        "-m",
        "pip",
        "install",
        "--no-build-isolation",  # required to force current version of setuptools
        "-e",
        str(project),
        *editable_opts,
    ]
    print(str(subprocess.check_output(cmd), "utf-8"))
    cmd = [venv.exe(), "-c", "import pkg, mod; print(pkg.a, mod.b)"]
    assert subprocess.check_output(cmd).strip() == b"4 2"


def test_editable_with_single_module(tmp_path, venv, editable_opts):
    files = {
        "mypkg": {
            "pyproject.toml": dedent(
                """\
                [build-system]
                requires = ["setuptools", "wheel"]
                build-backend = "setuptools.build_meta"

                [project]
                name = "mod"
                version = "3.14159"

                [tool.setuptools]
                py-modules = ["mod"]
                """
            ),
            "mod.py": "b = 2",
        },
    }
    jaraco.path.build(files, prefix=tmp_path)
    project = tmp_path / "mypkg"

    cmd = [
        venv.exe(),
        "-m",
        "pip",
        "install",
        "--no-build-isolation",  # required to force current version of setuptools
        "-e",
        str(project),
        *editable_opts,
    ]
    print(str(subprocess.check_output(cmd), "utf-8"))
    cmd = [venv.exe(), "-c", "import mod; print(mod.b)"]
    assert subprocess.check_output(cmd).strip() == b"2"


class TestLegacyNamespaces:
    """Ported from test_develop"""

    def test_namespace_package_importable(self, venv, tmp_path, editable_opts):
        """
        Installing two packages sharing the same namespace, one installed
        naturally using pip or `--single-version-externally-managed`
        and the other installed in editable mode should leave the namespace
        intact and both packages reachable by import.
        """
        build_system = """\
        [build-system]
        requires = ["setuptools"]
        build-backend = "setuptools.build_meta"
        """
        pkg_A = namespaces.build_namespace_package(tmp_path, 'myns.pkgA')
        pkg_B = namespaces.build_namespace_package(tmp_path, 'myns.pkgB')
        (pkg_A / "pyproject.toml").write_text(build_system, encoding="utf-8")
        (pkg_B / "pyproject.toml").write_text(build_system, encoding="utf-8")
        # use pip to install to the target directory
        opts = editable_opts[:]
        opts.append("--no-build-isolation")  # force current version of setuptools
        venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts])
        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts])
        venv.run(["python", "-c", "import myns.pkgA; import myns.pkgB"])
        # additionally ensure that pkg_resources import works
        venv.run(["python", "-c", "import pkg_resources"])


class TestPep420Namespaces:
    def test_namespace_package_importable(self, venv, tmp_path, editable_opts):
        """
        Installing two packages sharing the same namespace, one installed
        normally using pip and the other installed in editable mode
        should allow importing both packages.
        """
        pkg_A = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgA')
        pkg_B = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgB')
        # use pip to install to the target directory
        opts = editable_opts[:]
        opts.append("--no-build-isolation")  # force current version of setuptools
        venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts])
        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts])
        venv.run(["python", "-c", "import myns.n.pkgA; import myns.n.pkgB"])

    def test_namespace_created_via_package_dir(self, venv, tmp_path, editable_opts):
        """Currently users can create a namespace by tweaking `package_dir`"""
        files = {
            "pkgA": {
                "pyproject.toml": dedent(
                    """\
                    [build-system]
                    requires = ["setuptools", "wheel"]
                    build-backend = "setuptools.build_meta"

                    [project]
                    name = "pkgA"
                    version = "3.14159"

                    [tool.setuptools]
                    package-dir = {"myns.n.pkgA" = "src"}
                    """
                ),
                "src": {"__init__.py": "a = 1"},
            },
        }
        jaraco.path.build(files, prefix=tmp_path)
        pkg_A = tmp_path / "pkgA"
        pkg_B = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgB')
        pkg_C = namespaces.build_pep420_namespace_package(tmp_path, 'myns.n.pkgC')

        # use pip to install to the target directory
        opts = editable_opts[:]
        opts.append("--no-build-isolation")  # force current version of setuptools
        venv.run(["python", "-m", "pip", "install", str(pkg_A), *opts])
        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_B), *opts])
        venv.run(["python", "-m", "pip", "install", "-e", str(pkg_C), *opts])
        venv.run(["python", "-c", "from myns.n import pkgA, pkgB, pkgC"])

    def test_namespace_accidental_config_in_lenient_mode(self, venv, tmp_path):
        """Sometimes users might specify an ``include`` pattern that ignores parent
        packages. In a normal installation this would ignore all modules inside the
        parent packages, and make them namespaces (reported in issue #3504),
        so the editable mode should preserve this behaviour.
        """
        files = {
            "pkgA": {
                "pyproject.toml": dedent(
                    """\
                    [build-system]
                    requires = ["setuptools", "wheel"]
                    build-backend = "setuptools.build_meta"

                    [project]
                    name = "pkgA"
                    version = "3.14159"

                    [tool.setuptools]
                    packages.find.include = ["mypkg.*"]
                    """
                ),
                "mypkg": {
                    "__init__.py": "",
                    "other.py": "b = 1",
                    "n": {
                        "__init__.py": "",
                        "pkgA.py": "a = 1",
                    },
                },
                "MANIFEST.in": EXAMPLE["MANIFEST.in"],
            },
        }
        jaraco.path.build(files, prefix=tmp_path)
        pkg_A = tmp_path / "pkgA"

        # use pip to install to the target directory
        opts = ["--no-build-isolation"]  # force current version of setuptools
        venv.run(["python", "-m", "pip", "-v", "install", "-e", str(pkg_A), *opts])
        out = venv.run(["python", "-c", "from mypkg.n import pkgA; print(pkgA.a)"])
        assert str(out, "utf-8").strip() == "1"
        cmd = """\
        try:
            import mypkg.other
        except ImportError:
            print("mypkg.other not defined")
        """
        out = venv.run(["python", "-c", dedent(cmd)])
        assert "mypkg.other not defined" in str(out, "utf-8")


# Moved here from test_develop:
@pytest.mark.xfail(
    platform.python_implementation() == 'PyPy',
    reason="Workaround fails on PyPy (why?)",
)
def test_editable_with_prefix(tmp_path, sample_project, editable_opts):
    """
    Editable install to a prefix should be discoverable.
    """
    prefix = tmp_path / 'prefix'

    # figure out where pip will likely install the package
    site_packages = prefix / next(
        Path(path).relative_to(sys.prefix)
        for path in sys.path
        if 'site-packages' in path and path.startswith(sys.prefix)
    )
    site_packages.mkdir(parents=True)

    # install workaround
    _addsitedir(site_packages)

    env = dict(os.environ, PYTHONPATH=str(site_packages))
    cmd = [
        sys.executable,
        '-m',
        'pip',
        'install',
        '--editable',
        str(sample_project),
        '--prefix',
        str(prefix),
        '--no-build-isolation',
        *editable_opts,
    ]
    subprocess.check_call(cmd, env=env)

    # now run 'sample' with the prefix on the PYTHONPATH
    bin = 'Scripts' if platform.system() == 'Windows' else 'bin'
    exe = prefix / bin / 'sample'
    if sys.version_info < (3, 8) and platform.system() == 'Windows':
        exe = str(exe)
    subprocess.check_call([exe], env=env)


class TestFinderTemplate:
    """This test focus in getting a particular implementation detail right.
    If at some point in time the implementation is changed for something different,
    this test can be modified or even excluded.
    """

    def install_finder(self, finder):
        loc = {}
        exec(finder, loc, loc)
        loc["install"]()

    def test_packages(self, tmp_path):
        files = {
            "src1": {
                "pkg1": {
                    "__init__.py": "",
                    "subpkg": {"mod1.py": "a = 42"},
                },
            },
            "src2": {"mod2.py": "a = 43"},
        }
        jaraco.path.build(files, prefix=tmp_path)

        mapping = {
            "pkg1": str(tmp_path / "src1/pkg1"),
            "mod2": str(tmp_path / "src2/mod2"),
        }
        template = _finder_template(str(uuid4()), mapping, {})

        with contexts.save_paths(), contexts.save_sys_modules():
            for mod in ("pkg1", "pkg1.subpkg", "pkg1.subpkg.mod1", "mod2"):
                sys.modules.pop(mod, None)

            self.install_finder(template)
            mod1 = import_module("pkg1.subpkg.mod1")
            mod2 = import_module("mod2")
            subpkg = import_module("pkg1.subpkg")

            assert mod1.a == 42
            assert mod2.a == 43
            expected = str((tmp_path / "src1/pkg1/subpkg").resolve())
            assert_path(subpkg, expected)

    def test_namespace(self, tmp_path):
        files = {"pkg": {"__init__.py": "a = 13", "text.txt": "abc"}}
        jaraco.path.build(files, prefix=tmp_path)

        mapping = {"ns.othername": str(tmp_path / "pkg")}
        namespaces = {"ns": []}

        template = _finder_template(str(uuid4()), mapping, namespaces)
        with contexts.save_paths(), contexts.save_sys_modules():
            for mod in ("ns", "ns.othername"):
                sys.modules.pop(mod, None)

            self.install_finder(template)
            pkg = import_module("ns.othername")
            text = importlib_resources.files(pkg) / "text.txt"

            expected = str((tmp_path / "pkg").resolve())
            assert_path(pkg, expected)
            assert pkg.a == 13

            # Make sure resources can also be found
            assert text.read_text(encoding="utf-8") == "abc"

    def test_combine_namespaces(self, tmp_path):
        files = {
            "src1": {"ns": {"pkg1": {"__init__.py": "a = 13"}}},
            "src2": {"ns": {"mod2.py": "b = 37"}},
        }
        jaraco.path.build(files, prefix=tmp_path)

        mapping = {
            "ns.pkgA": str(tmp_path / "src1/ns/pkg1"),
            "ns": str(tmp_path / "src2/ns"),
        }
        namespaces_ = {"ns": [str(tmp_path / "src1"), str(tmp_path / "src2")]}
        template = _finder_template(str(uuid4()), mapping, namespaces_)

        with contexts.save_paths(), contexts.save_sys_modules():
            for mod in ("ns", "ns.pkgA", "ns.mod2"):
                sys.modules.pop(mod, None)

            self.install_finder(template)
            pkgA = import_module("ns.pkgA")
            mod2 = import_module("ns.mod2")

            expected = str((tmp_path / "src1/ns/pkg1").resolve())
            assert_path(pkgA, expected)
            assert pkgA.a == 13
            assert mod2.b == 37

    def test_dynamic_path_computation(self, tmp_path):
        # Follows the example in PEP 420
        files = {
            "project1": {"parent": {"child": {"one.py": "x = 1"}}},
            "project2": {"parent": {"child": {"two.py": "x = 2"}}},
            "project3": {"parent": {"child": {"three.py": "x = 3"}}},
        }
        jaraco.path.build(files, prefix=tmp_path)
        mapping = {}
        namespaces_ = {"parent": [str(tmp_path / "project1/parent")]}
        template = _finder_template(str(uuid4()), mapping, namespaces_)

        mods = (f"parent.child.{name}" for name in ("one", "two", "three"))
        with contexts.save_paths(), contexts.save_sys_modules():
            for mod in ("parent", "parent.child", "parent.child", *mods):
                sys.modules.pop(mod, None)

            self.install_finder(template)

            one = import_module("parent.child.one")
            assert one.x == 1

            with pytest.raises(ImportError):
                import_module("parent.child.two")

            sys.path.append(str(tmp_path / "project2"))
            two = import_module("parent.child.two")
            assert two.x == 2

            with pytest.raises(ImportError):
                import_module("parent.child.three")

            sys.path.append(str(tmp_path / "project3"))
            three = import_module("parent.child.three")
            assert three.x == 3

    def test_no_recursion(self, tmp_path):
        # See issue #3550
        files = {
            "pkg": {
                "__init__.py": "from . import pkg",
            },
        }
        jaraco.path.build(files, prefix=tmp_path)

        mapping = {
            "pkg": str(tmp_path / "pkg"),
        }
        template = _finder_template(str(uuid4()), mapping, {})

        with contexts.save_paths(), contexts.save_sys_modules():
            sys.modules.pop("pkg", None)

            self.install_finder(template)
            with pytest.raises(ImportError, match="pkg"):
                import_module("pkg")

    def test_similar_name(self, tmp_path):
        files = {
            "foo": {
                "__init__.py": "",
                "bar": {
                    "__init__.py": "",
                },
            },
        }
        jaraco.path.build(files, prefix=tmp_path)

        mapping = {
            "foo": str(tmp_path / "foo"),
        }
        template = _finder_template(str(uuid4()), mapping, {})

        with contexts.save_paths(), contexts.save_sys_modules():
            sys.modules.pop("foo", None)
            sys.modules.pop("foo.bar", None)

            self.install_finder(template)
            with pytest.raises(ImportError, match="foobar"):
                import_module("foobar")

    def test_case_sensitivity(self, tmp_path):
        files = {
            "foo": {
                "__init__.py": "",
                "lowercase.py": "x = 1",
                "bar": {
                    "__init__.py": "",
                    "lowercase.py": "x = 2",
                },
            },
        }
        jaraco.path.build(files, prefix=tmp_path)
        mapping = {
            "foo": str(tmp_path / "foo"),
        }
        template = _finder_template(str(uuid4()), mapping, {})
        with contexts.save_paths(), contexts.save_sys_modules():
            sys.modules.pop("foo", None)

            self.install_finder(template)
            with pytest.raises(ImportError, match="\'FOO\'"):
                import_module("FOO")

            with pytest.raises(ImportError, match="\'foo\\.LOWERCASE\'"):
                import_module("foo.LOWERCASE")

            with pytest.raises(ImportError, match="\'foo\\.bar\\.Lowercase\'"):
                import_module("foo.bar.Lowercase")

            with pytest.raises(ImportError, match="\'foo\\.BAR\'"):
                import_module("foo.BAR.lowercase")

            with pytest.raises(ImportError, match="\'FOO\'"):
                import_module("FOO.bar.lowercase")

            mod = import_module("foo.lowercase")
            assert mod.x == 1

            mod = import_module("foo.bar.lowercase")
            assert mod.x == 2

    def test_namespace_case_sensitivity(self, tmp_path):
        files = {
            "pkg": {
                "__init__.py": "a = 13",
                "foo": {
                    "__init__.py": "b = 37",
                    "bar.py": "c = 42",
                },
            },
        }
        jaraco.path.build(files, prefix=tmp_path)

        mapping = {"ns.othername": str(tmp_path / "pkg")}
        namespaces = {"ns": []}

        template = _finder_template(str(uuid4()), mapping, namespaces)
        with contexts.save_paths(), contexts.save_sys_modules():
            for mod in ("ns", "ns.othername"):
                sys.modules.pop(mod, None)

            self.install_finder(template)
            pkg = import_module("ns.othername")
            expected = str((tmp_path / "pkg").resolve())
            assert_path(pkg, expected)
            assert pkg.a == 13

            foo = import_module("ns.othername.foo")
            assert foo.b == 37

            bar = import_module("ns.othername.foo.bar")
            assert bar.c == 42

            with pytest.raises(ImportError, match="\'NS\'"):
                import_module("NS.othername.foo")

            with pytest.raises(ImportError, match="\'ns\\.othername\\.FOO\\'"):
                import_module("ns.othername.FOO")

            with pytest.raises(ImportError, match="\'ns\\.othername\\.foo\\.BAR\\'"):
                import_module("ns.othername.foo.BAR")

    def test_intermediate_packages(self, tmp_path):
        """
        The finder should not import ``fullname`` if the intermediate segments
        don't exist (see pypa/setuptools#4019).
        """
        files = {
            "src": {
                "mypkg": {
                    "__init__.py": "",
                    "config.py": "a = 13",
                    "helloworld.py": "b = 13",
                    "components": {
                        "config.py": "a = 37",
                    },
                },
            }
        }
        jaraco.path.build(files, prefix=tmp_path)

        mapping = {"mypkg": str(tmp_path / "src/mypkg")}
        template = _finder_template(str(uuid4()), mapping, {})

        with contexts.save_paths(), contexts.save_sys_modules():
            for mod in (
                "mypkg",
                "mypkg.config",
                "mypkg.helloworld",
                "mypkg.components",
                "mypkg.components.config",
                "mypkg.components.helloworld",
            ):
                sys.modules.pop(mod, None)

            self.install_finder(template)

            config = import_module("mypkg.components.config")
            assert config.a == 37

            helloworld = import_module("mypkg.helloworld")
            assert helloworld.b == 13

            with pytest.raises(ImportError):
                import_module("mypkg.components.helloworld")


def test_pkg_roots(tmp_path):
    """This test focus in getting a particular implementation detail right.
    If at some point in time the implementation is changed for something different,
    this test can be modified or even excluded.
    """
    files = {
        "a": {"b": {"__init__.py": "ab = 1"}, "__init__.py": "a = 1"},
        "d": {"__init__.py": "d = 1", "e": {"__init__.py": "de = 1"}},
        "f": {"g": {"h": {"__init__.py": "fgh = 1"}}},
        "other": {"__init__.py": "abc = 1"},
        "another": {"__init__.py": "abcxyz = 1"},
        "yet_another": {"__init__.py": "mnopq = 1"},
    }
    jaraco.path.build(files, prefix=tmp_path)
    package_dir = {
        "a.b.c": "other",
        "a.b.c.x.y.z": "another",
        "m.n.o.p.q": "yet_another",
    }
    packages = [
        "a",
        "a.b",
        "a.b.c",
        "a.b.c.x.y",
        "a.b.c.x.y.z",
        "d",
        "d.e",
        "f",
        "f.g",
        "f.g.h",
        "m.n.o.p.q",
    ]
    roots = _find_package_roots(packages, package_dir, tmp_path)
    assert roots == {
        "a": str(tmp_path / "a"),
        "a.b.c": str(tmp_path / "other"),
        "a.b.c.x.y.z": str(tmp_path / "another"),
        "d": str(tmp_path / "d"),
        "f": str(tmp_path / "f"),
        "m.n.o.p.q": str(tmp_path / "yet_another"),
    }

    ns = set(dict(_find_namespaces(packages, roots)))
    assert ns == {"f", "f.g"}

    ns = set(_find_virtual_namespaces(roots))
    assert ns == {"a.b", "a.b.c.x", "a.b.c.x.y", "m", "m.n", "m.n.o", "m.n.o.p"}


class TestOverallBehaviour:
    PYPROJECT = """\
        [build-system]
        requires = ["setuptools"]
        build-backend = "setuptools.build_meta"

        [project]
        name = "mypkg"
        version = "3.14159"
        """

    FLAT_LAYOUT = {
        "pyproject.toml": dedent(PYPROJECT),
        "MANIFEST.in": EXAMPLE["MANIFEST.in"],
        "otherfile.py": "",
        "mypkg": {
            "__init__.py": "",
            "mod1.py": "var = 42",
            "subpackage": {
                "__init__.py": "",
                "mod2.py": "var = 13",
                "resource_file.txt": "resource 39",
            },
        },
    }

    EXAMPLES = {
        "flat-layout": FLAT_LAYOUT,
        "src-layout": {
            "pyproject.toml": dedent(PYPROJECT),
            "MANIFEST.in": EXAMPLE["MANIFEST.in"],
            "otherfile.py": "",
            "src": {"mypkg": FLAT_LAYOUT["mypkg"]},
        },
        "custom-layout": {
            "pyproject.toml": dedent(PYPROJECT)
            + dedent(
                """\
                [tool.setuptools]
                packages = ["mypkg", "mypkg.subpackage"]

                [tool.setuptools.package-dir]
                "mypkg.subpackage" = "other"
                """
            ),
            "MANIFEST.in": EXAMPLE["MANIFEST.in"],
            "otherfile.py": "",
            "mypkg": {
                "__init__.py": "",
                "mod1.py": FLAT_LAYOUT["mypkg"]["mod1.py"],  # type: ignore
            },
            "other": FLAT_LAYOUT["mypkg"]["subpackage"],  # type: ignore
        },
        "namespace": {
            "pyproject.toml": dedent(PYPROJECT),
            "MANIFEST.in": EXAMPLE["MANIFEST.in"],
            "otherfile.py": "",
            "src": {
                "mypkg": {
                    "mod1.py": FLAT_LAYOUT["mypkg"]["mod1.py"],  # type: ignore
                    "subpackage": FLAT_LAYOUT["mypkg"]["subpackage"],  # type: ignore
                },
            },
        },
    }

    @pytest.mark.parametrize("layout", EXAMPLES.keys())
    def test_editable_install(self, tmp_path, venv, layout, editable_opts):
        project, _ = install_project(
            "mypkg", venv, tmp_path, self.EXAMPLES[layout], *editable_opts
        )

        # Ensure stray files are not importable
        cmd_import_error = """\
        try:
            import otherfile
        except ImportError as ex:
            print(ex)
        """
        out = venv.run(["python", "-c", dedent(cmd_import_error)])
        assert b"No module named 'otherfile'" in out

        # Ensure the modules are importable
        cmd_get_vars = """\
        import mypkg, mypkg.mod1, mypkg.subpackage.mod2
        print(mypkg.mod1.var, mypkg.subpackage.mod2.var)
        """
        out = venv.run(["python", "-c", dedent(cmd_get_vars)])
        assert b"42 13" in out

        # Ensure resources are reachable
        cmd_get_resource = """\
        import mypkg.subpackage
        from setuptools._importlib import resources as importlib_resources
        text = importlib_resources.files(mypkg.subpackage) / "resource_file.txt"
        print(text.read_text(encoding="utf-8"))
        """
        out = venv.run(["python", "-c", dedent(cmd_get_resource)])
        assert b"resource 39" in out

        # Ensure files are editable
        mod1 = next(project.glob("**/mod1.py"))
        mod2 = next(project.glob("**/mod2.py"))
        resource_file = next(project.glob("**/resource_file.txt"))

        mod1.write_text("var = 17", encoding="utf-8")
        mod2.write_text("var = 781", encoding="utf-8")
        resource_file.write_text("resource 374", encoding="utf-8")

        out = venv.run(["python", "-c", dedent(cmd_get_vars)])
        assert b"42 13" not in out
        assert b"17 781" in out

        out = venv.run(["python", "-c", dedent(cmd_get_resource)])
        assert b"resource 39" not in out
        assert b"resource 374" in out


class TestLinkTree:
    FILES = deepcopy(TestOverallBehaviour.EXAMPLES["src-layout"])
    FILES["pyproject.toml"] += dedent(
        """\
        [tool.setuptools]
        # Temporary workaround: both `include-package-data` and `package-data` configs
        # can be removed after #3260 is fixed.
        include-package-data = false
        package-data = {"*" = ["*.txt"]}

        [tool.setuptools.packages.find]
        where = ["src"]
        exclude = ["*.subpackage*"]
        """
    )
    FILES["src"]["mypkg"]["resource.not_in_manifest"] = "abc"

    def test_generated_tree(self, tmp_path):
        jaraco.path.build(self.FILES, prefix=tmp_path)

        with _Path(tmp_path):
            name = "mypkg-3.14159"
            dist = Distribution({"script_name": "%PEP 517%"})
            dist.parse_config_files()

            wheel = Mock()
            aux = tmp_path / ".aux"
            build = tmp_path / ".build"
            aux.mkdir()
            build.mkdir()

            build_py = dist.get_command_obj("build_py")
            build_py.editable_mode = True
            build_py.build_lib = str(build)
            build_py.ensure_finalized()
            outputs = build_py.get_outputs()
            output_mapping = build_py.get_output_mapping()

            make_tree = _LinkTree(dist, name, aux, build)
            make_tree(wheel, outputs, output_mapping)

            mod1 = next(aux.glob("**/mod1.py"))
            expected = tmp_path / "src/mypkg/mod1.py"
            assert_link_to(mod1, expected)

            assert next(aux.glob("**/subpackage"), None) is None
            assert next(aux.glob("**/mod2.py"), None) is None
            assert next(aux.glob("**/resource_file.txt"), None) is None

            assert next(aux.glob("**/resource.not_in_manifest"), None) is None

    def test_strict_install(self, tmp_path, venv):
        opts = ["--config-settings", "editable-mode=strict"]
        install_project("mypkg", venv, tmp_path, self.FILES, *opts)

        out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"])
        assert b"42" in out

        # Ensure packages excluded from distribution are not importable
        cmd_import_error = """\
        try:
            from mypkg import subpackage
        except ImportError as ex:
            print(ex)
        """
        out = venv.run(["python", "-c", dedent(cmd_import_error)])
        assert b"cannot import name 'subpackage'" in out

        # Ensure resource files excluded from distribution are not reachable
        cmd_get_resource = """\
        import mypkg
        from setuptools._importlib import resources as importlib_resources
        try:
            text = importlib_resources.files(mypkg) / "resource.not_in_manifest"
            print(text.read_text(encoding="utf-8"))
        except FileNotFoundError as ex:
            print(ex)
        """
        out = venv.run(["python", "-c", dedent(cmd_get_resource)])
        assert b"No such file or directory" in out
        assert b"resource.not_in_manifest" in out


@pytest.mark.filterwarnings("ignore:.*compat.*:setuptools.SetuptoolsDeprecationWarning")
def test_compat_install(tmp_path, venv):
    # TODO: Remove `compat` after Dec/2022.
    opts = ["--config-settings", "editable-mode=compat"]
    files = TestOverallBehaviour.EXAMPLES["custom-layout"]
    install_project("mypkg", venv, tmp_path, files, *opts)

    out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"])
    assert b"42" in out

    expected_path = comparable_path(str(tmp_path))

    # Compatible behaviour will make spurious modules and excluded
    # files importable directly from the original path
    for cmd in (
        "import otherfile; print(otherfile)",
        "import other; print(other)",
        "import mypkg; print(mypkg)",
    ):
        out = comparable_path(str(venv.run(["python", "-c", cmd]), "utf-8"))
        assert expected_path in out

    # Compatible behaviour will not consider custom mappings
    cmd = """\
    try:
        from mypkg import subpackage;
    except ImportError as ex:
        print(ex)
    """
    out = str(venv.run(["python", "-c", dedent(cmd)]), "utf-8")
    assert "cannot import name 'subpackage'" in out


def test_pbr_integration(tmp_path, venv, editable_opts):
    """Ensure editable installs work with pbr, issue #3500"""
    files = {
        "pyproject.toml": dedent(
            """\
            [build-system]
            requires = ["setuptools"]
            build-backend = "setuptools.build_meta"
            """
        ),
        "setup.py": dedent(
            """\
            __import__('setuptools').setup(
                pbr=True,
                setup_requires=["pbr"],
            )
            """
        ),
        "setup.cfg": dedent(
            """\
            [metadata]
            name = mypkg

            [files]
            packages =
                mypkg
            """
        ),
        "mypkg": {
            "__init__.py": "",
            "hello.py": "print('Hello world!')",
        },
        "other": {"test.txt": "Another file in here."},
    }
    venv.run(["python", "-m", "pip", "install", "pbr"])

    with contexts.environment(PBR_VERSION="0.42"):
        install_project("mypkg", venv, tmp_path, files, *editable_opts)

    out = venv.run(["python", "-c", "import mypkg.hello"])
    assert b"Hello world!" in out


class TestCustomBuildPy:
    """
    Issue #3501 indicates that some plugins/customizations might rely on:

    1. ``build_py`` not running
    2. ``build_py`` always copying files to ``build_lib``

    During the transition period setuptools should prevent potential errors from
    happening due to those assumptions.
    """

    # TODO: Remove tests after _run_build_steps is removed.

    FILES = {
        **TestOverallBehaviour.EXAMPLES["flat-layout"],
        "setup.py": dedent(
            """\
            import pathlib
            from setuptools import setup
            from setuptools.command.build_py import build_py as orig

            class my_build_py(orig):
                def run(self):
                    super().run()
                    raise ValueError("TEST_RAISE")

            setup(cmdclass={"build_py": my_build_py})
            """
        ),
    }

    def test_safeguarded_from_errors(self, tmp_path, venv):
        """Ensure that errors in custom build_py are reported as warnings"""
        # Warnings should show up
        _, out = install_project("mypkg", venv, tmp_path, self.FILES)
        assert b"SetuptoolsDeprecationWarning" in out
        assert b"ValueError: TEST_RAISE" in out
        # but installation should be successful
        out = venv.run(["python", "-c", "import mypkg.mod1; print(mypkg.mod1.var)"])
        assert b"42" in out


class TestCustomBuildWheel:
    def install_custom_build_wheel(self, dist):
        bdist_wheel_cls = dist.get_command_class("bdist_wheel")

        class MyBdistWheel(bdist_wheel_cls):
            def get_tag(self):
                # In issue #3513, we can see that some extensions may try to access
                # the `plat_name` property in bdist_wheel
                if self.plat_name.startswith("macosx-"):
                    _ = "macOS platform"
                return super().get_tag()

        dist.cmdclass["bdist_wheel"] = MyBdistWheel

    def test_access_plat_name(self, tmpdir_cwd):
        # Even when a custom bdist_wheel tries to access plat_name the build should
        # be successful
        jaraco.path.build({"module.py": "x = 42"})
        dist = Distribution()
        dist.script_name = "setup.py"
        dist.set_defaults()
        self.install_custom_build_wheel(dist)
        cmd = editable_wheel(dist)
        cmd.ensure_finalized()
        cmd.run()
        wheel_file = str(next(Path().glob('dist/*.whl')))
        assert "editable" in wheel_file


class TestCustomBuildExt:
    def install_custom_build_ext_distutils(self, dist):
        from distutils.command.build_ext import build_ext as build_ext_cls

        class MyBuildExt(build_ext_cls):
            pass

        dist.cmdclass["build_ext"] = MyBuildExt

    @pytest.mark.skipif(
        sys.platform != "linux", reason="compilers may fail without correct setup"
    )
    def test_distutils_leave_inplace_files(self, tmpdir_cwd):
        jaraco.path.build({"module.c": ""})
        attrs = {
            "ext_modules": [Extension("module", ["module.c"])],
        }
        dist = Distribution(attrs)
        dist.script_name = "setup.py"
        dist.set_defaults()
        self.install_custom_build_ext_distutils(dist)
        cmd = editable_wheel(dist)
        cmd.ensure_finalized()
        cmd.run()
        wheel_file = str(next(Path().glob('dist/*.whl')))
        assert "editable" in wheel_file
        files = [p for p in Path().glob("module.*") if p.suffix != ".c"]
        assert len(files) == 1
        name = files[0].name
        assert any(name.endswith(ext) for ext in EXTENSION_SUFFIXES)


def test_debugging_tips(tmpdir_cwd, monkeypatch):
    """Make sure to display useful debugging tips to the user."""
    jaraco.path.build({"module.py": "x = 42"})
    dist = Distribution()
    dist.script_name = "setup.py"
    dist.set_defaults()
    cmd = editable_wheel(dist)
    cmd.ensure_finalized()

    SimulatedErr = type("SimulatedErr", (Exception,), {})
    simulated_failure = Mock(side_effect=SimulatedErr())
    monkeypatch.setattr(cmd, "get_finalized_command", simulated_failure)

    expected_msg = "following steps are recommended to help debugging"
    with pytest.raises(SimulatedErr), pytest.warns(_DebuggingTips, match=expected_msg):
        cmd.run()


@pytest.mark.filterwarnings("error")
def test_encode_pth():
    """Ensure _encode_pth function does not produce encoding warnings"""
    content = _encode_pth("tkmilan_ç_utf8")  # no warnings (would be turned into errors)
    assert isinstance(content, bytes)


def install_project(name, venv, tmp_path, files, *opts):
    project = tmp_path / name
    project.mkdir()
    jaraco.path.build(files, prefix=project)
    opts = [*opts, "--no-build-isolation"]  # force current version of setuptools
    out = venv.run(
        ["python", "-m", "pip", "-v", "install", "-e", str(project), *opts],
        stderr=subprocess.STDOUT,
    )
    return project, out


def _addsitedir(new_dir: Path):
    """To use this function, it is necessary to insert new_dir in front of sys.path.
    The Python process will try to import a ``sitecustomize`` module on startup.
    If we manipulate sys.path/PYTHONPATH, we can force it to run our code,
    which invokes ``addsitedir`` and ensure ``.pth`` files are loaded.
    """
    file = f"import site; site.addsitedir({os.fspath(new_dir)!r})\n"
    (new_dir / "sitecustomize.py").write_text(file, encoding="utf-8")


# ---- Assertion Helpers ----


def assert_path(pkg, expected):
    # __path__ is not guaranteed to exist, so we have to account for that
    if pkg.__path__:
        path = next(iter(pkg.__path__), None)
        if path:
            assert str(Path(path).resolve()) == expected


def assert_link_to(file: Path, other: Path):
    if file.is_symlink():
        assert str(file.resolve()) == str(other.resolve())
    else:
        file_stat = file.stat()
        other_stat = other.stat()
        assert file_stat[stat.ST_INO] == other_stat[stat.ST_INO]
        assert file_stat[stat.ST_DEV] == other_stat[stat.ST_DEV]


def comparable_path(str_with_path: str) -> str:
    return str_with_path.lower().replace(os.sep, "/").replace("//", "/")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_egg_info.py0000644000175100001730000012750614467657412022236 0ustar00runnerdockerimport sys
import ast
import os
import glob
import re
import stat
import time
from typing import List, Tuple
from pathlib import Path
from unittest import mock

import pytest
from jaraco import path

from setuptools import errors
from setuptools.command.egg_info import (
    egg_info,
    manifest_maker,
    write_entries,
)
from setuptools.dist import Distribution

from . import environment
from .textwrap import DALS
from . import contexts


class Environment(str):
    pass


@pytest.fixture
def env():
    with contexts.tempdir(prefix='setuptools-test.') as env_dir:
        env = Environment(env_dir)
        os.chmod(env_dir, stat.S_IRWXU)
        subs = 'home', 'lib', 'scripts', 'data', 'egg-base'
        env.paths = dict((dirname, os.path.join(env_dir, dirname)) for dirname in subs)
        list(map(os.mkdir, env.paths.values()))
        path.build(
            {
                env.paths['home']: {
                    '.pydistutils.cfg': DALS(
                        """
                [egg_info]
                egg-base = %(egg-base)s
                """
                        % env.paths
                    )
                }
            }
        )
        yield env


class TestEggInfo:
    setup_script = DALS(
        """
        from setuptools import setup

        setup(
            name='foo',
            py_modules=['hello'],
            entry_points={'console_scripts': ['hi = hello.run']},
            zip_safe=False,
        )
        """
    )

    def _create_project(self):
        path.build(
            {
                'setup.py': self.setup_script,
                'hello.py': DALS(
                    """
                def run():
                    print('hello')
                """
                ),
            }
        )

    @staticmethod
    def _extract_mv_version(pkg_info_lines: List[str]) -> Tuple[int, int]:
        version_str = pkg_info_lines[0].split(' ')[1]
        return tuple(map(int, version_str.split('.')[:2]))

    def test_egg_info_save_version_info_setup_empty(self, tmpdir_cwd, env):
        """
        When the egg_info section is empty or not present, running
        save_version_info should add the settings to the setup.cfg
        in a deterministic order.
        """
        setup_cfg = os.path.join(env.paths['home'], 'setup.cfg')
        dist = Distribution()
        ei = egg_info(dist)
        ei.initialize_options()
        ei.save_version_info(setup_cfg)

        with open(setup_cfg, 'r') as f:
            content = f.read()

        assert '[egg_info]' in content
        assert 'tag_build =' in content
        assert 'tag_date = 0' in content

        expected_order = (
            'tag_build',
            'tag_date',
        )

        self._validate_content_order(content, expected_order)

    @staticmethod
    def _validate_content_order(content, expected):
        """
        Assert that the strings in expected appear in content
        in order.
        """
        pattern = '.*'.join(expected)
        flags = re.MULTILINE | re.DOTALL
        assert re.search(pattern, content, flags)

    def test_egg_info_save_version_info_setup_defaults(self, tmpdir_cwd, env):
        """
        When running save_version_info on an existing setup.cfg
        with the 'default' values present from a previous run,
        the file should remain unchanged.
        """
        setup_cfg = os.path.join(env.paths['home'], 'setup.cfg')
        path.build(
            {
                setup_cfg: DALS(
                    """
            [egg_info]
            tag_build =
            tag_date = 0
            """
                ),
            }
        )
        dist = Distribution()
        ei = egg_info(dist)
        ei.initialize_options()
        ei.save_version_info(setup_cfg)

        with open(setup_cfg, 'r') as f:
            content = f.read()

        assert '[egg_info]' in content
        assert 'tag_build =' in content
        assert 'tag_date = 0' in content

        expected_order = (
            'tag_build',
            'tag_date',
        )

        self._validate_content_order(content, expected_order)

    def test_expected_files_produced(self, tmpdir_cwd, env):
        self._create_project()

        self._run_egg_info_command(tmpdir_cwd, env)
        actual = os.listdir('foo.egg-info')

        expected = [
            'PKG-INFO',
            'SOURCES.txt',
            'dependency_links.txt',
            'entry_points.txt',
            'not-zip-safe',
            'top_level.txt',
        ]
        assert sorted(actual) == expected

    def test_handling_utime_error(self, tmpdir_cwd, env):
        dist = Distribution()
        ei = egg_info(dist)
        utime_patch = mock.patch('os.utime', side_effect=OSError("TEST"))
        mkpath_patch = mock.patch(
            'setuptools.command.egg_info.egg_info.mkpath', return_val=None
        )

        with utime_patch, mkpath_patch:
            import distutils.errors

            msg = r"Cannot update time stamp of directory 'None'"
            with pytest.raises(distutils.errors.DistutilsFileError, match=msg):
                ei.run()

    def test_license_is_a_string(self, tmpdir_cwd, env):
        setup_config = DALS(
            """
            [metadata]
            name=foo
            version=0.0.1
            license=file:MIT
            """
        )

        setup_script = DALS(
            """
            from setuptools import setup

            setup()
            """
        )

        path.build(
            {
                'setup.py': setup_script,
                'setup.cfg': setup_config,
            }
        )

        # This command should fail with a ValueError, but because it's
        # currently configured to use a subprocess, the actual traceback
        # object is lost and we need to parse it from stderr
        with pytest.raises(AssertionError) as exc:
            self._run_egg_info_command(tmpdir_cwd, env)

        # Hopefully this is not too fragile: the only argument to the
        # assertion error should be a traceback, ending with:
        #     ValueError: ....
        #
        #     assert not 1
        tb = exc.value.args[0].split('\n')
        assert tb[-3].lstrip().startswith('ValueError')

    def test_rebuilt(self, tmpdir_cwd, env):
        """Ensure timestamps are updated when the command is re-run."""
        self._create_project()

        self._run_egg_info_command(tmpdir_cwd, env)
        timestamp_a = os.path.getmtime('foo.egg-info')

        # arbitrary sleep just to handle *really* fast systems
        time.sleep(0.001)

        self._run_egg_info_command(tmpdir_cwd, env)
        timestamp_b = os.path.getmtime('foo.egg-info')

        assert timestamp_a != timestamp_b

    def test_manifest_template_is_read(self, tmpdir_cwd, env):
        self._create_project()
        path.build(
            {
                'MANIFEST.in': DALS(
                    """
                recursive-include docs *.rst
            """
                ),
                'docs': {
                    'usage.rst': "Run 'hi'",
                },
            }
        )
        self._run_egg_info_command(tmpdir_cwd, env)
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        sources_txt = os.path.join(egg_info_dir, 'SOURCES.txt')
        with open(sources_txt) as f:
            assert 'docs/usage.rst' in f.read().split('\n')

    def _setup_script_with_requires(self, requires, use_setup_cfg=False):
        setup_script = (
            DALS(
                '''
            from setuptools import setup

            setup(name='foo', zip_safe=False, %s)
            '''
            )
            % ('' if use_setup_cfg else requires)
        )
        setup_config = requires if use_setup_cfg else ''
        path.build(
            {
                'setup.py': setup_script,
                'setup.cfg': setup_config,
            }
        )

    mismatch_marker = "python_version<'{this_ver}'".format(
        this_ver=sys.version_info[0],
    )
    # Alternate equivalent syntax.
    mismatch_marker_alternate = 'python_version < "{this_ver}"'.format(
        this_ver=sys.version_info[0],
    )
    invalid_marker = "<=>++"

    class RequiresTestHelper:
        @staticmethod
        def parametrize(*test_list, **format_dict):
            idlist = []
            argvalues = []
            for test in test_list:
                test_params = test.lstrip().split('\n\n', 3)
                name_kwargs = test_params.pop(0).split('\n')
                if len(name_kwargs) > 1:
                    val = name_kwargs[1].strip()
                    install_cmd_kwargs = ast.literal_eval(val)
                else:
                    install_cmd_kwargs = {}
                name = name_kwargs[0].strip()
                setup_py_requires, setup_cfg_requires, expected_requires = (
                    DALS(a).format(**format_dict) for a in test_params
                )
                for id_, requires, use_cfg in (
                    (name, setup_py_requires, False),
                    (name + '_in_setup_cfg', setup_cfg_requires, True),
                ):
                    idlist.append(id_)
                    marks = ()
                    if requires.startswith('@xfail\n'):
                        requires = requires[7:]
                        marks = pytest.mark.xfail
                    argvalues.append(
                        pytest.param(
                            requires,
                            use_cfg,
                            expected_requires,
                            install_cmd_kwargs,
                            marks=marks,
                        )
                    )
            return pytest.mark.parametrize(
                'requires,use_setup_cfg,' 'expected_requires,install_cmd_kwargs',
                argvalues,
                ids=idlist,
            )

    @RequiresTestHelper.parametrize(
        # Format of a test:
        #
        # id
        # install_cmd_kwargs [optional]
        #
        # requires block (when used in setup.py)
        #
        # requires block (when used in setup.cfg)
        #
        # expected contents of requires.txt
        '''
        install_requires_deterministic

        install_requires=["wheel>=0.5", "pytest"]

        [options]
        install_requires =
            wheel>=0.5
            pytest

        wheel>=0.5
        pytest
        ''',
        '''
        install_requires_ordered

        install_requires=["pytest>=3.0.2,!=10.9999"]

        [options]
        install_requires =
            pytest>=3.0.2,!=10.9999

        pytest!=10.9999,>=3.0.2
        ''',
        '''
        install_requires_with_marker

        install_requires=["barbazquux;{mismatch_marker}"],

        [options]
        install_requires =
            barbazquux; {mismatch_marker}

        [:{mismatch_marker_alternate}]
        barbazquux
        ''',
        '''
        install_requires_with_extra
        {'cmd': ['egg_info']}

        install_requires=["barbazquux [test]"],

        [options]
        install_requires =
            barbazquux [test]

        barbazquux[test]
        ''',
        '''
        install_requires_with_extra_and_marker

        install_requires=["barbazquux [test]; {mismatch_marker}"],

        [options]
        install_requires =
            barbazquux [test]; {mismatch_marker}

        [:{mismatch_marker_alternate}]
        barbazquux[test]
        ''',
        '''
        setup_requires_with_markers

        setup_requires=["barbazquux;{mismatch_marker}"],

        [options]
        setup_requires =
            barbazquux; {mismatch_marker}

        ''',
        '''
        tests_require_with_markers
        {'cmd': ['test'], 'output': "Ran 0 tests in"}

        tests_require=["barbazquux;{mismatch_marker}"],

        [options]
        tests_require =
            barbazquux; {mismatch_marker}

        ''',
        '''
        extras_require_with_extra
        {'cmd': ['egg_info']}

        extras_require={{"extra": ["barbazquux [test]"]}},

        [options.extras_require]
        extra = barbazquux [test]

        [extra]
        barbazquux[test]
        ''',
        '''
        extras_require_with_extra_and_marker_in_req

        extras_require={{"extra": ["barbazquux [test]; {mismatch_marker}"]}},

        [options.extras_require]
        extra =
            barbazquux [test]; {mismatch_marker}

        [extra]

        [extra:{mismatch_marker_alternate}]
        barbazquux[test]
        ''',
        # FIXME: ConfigParser does not allow : in key names!
        '''
        extras_require_with_marker

        extras_require={{":{mismatch_marker}": ["barbazquux"]}},

        @xfail
        [options.extras_require]
        :{mismatch_marker} = barbazquux

        [:{mismatch_marker}]
        barbazquux
        ''',
        '''
        extras_require_with_marker_in_req

        extras_require={{"extra": ["barbazquux; {mismatch_marker}"]}},

        [options.extras_require]
        extra =
            barbazquux; {mismatch_marker}

        [extra]

        [extra:{mismatch_marker_alternate}]
        barbazquux
        ''',
        '''
        extras_require_with_empty_section

        extras_require={{"empty": []}},

        [options.extras_require]
        empty =

        [empty]
        ''',
        # Format arguments.
        invalid_marker=invalid_marker,
        mismatch_marker=mismatch_marker,
        mismatch_marker_alternate=mismatch_marker_alternate,
    )
    def test_requires(
        self,
        tmpdir_cwd,
        env,
        requires,
        use_setup_cfg,
        expected_requires,
        install_cmd_kwargs,
    ):
        self._setup_script_with_requires(requires, use_setup_cfg)
        self._run_egg_info_command(tmpdir_cwd, env, **install_cmd_kwargs)
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        requires_txt = os.path.join(egg_info_dir, 'requires.txt')
        if os.path.exists(requires_txt):
            with open(requires_txt) as fp:
                install_requires = fp.read()
        else:
            install_requires = ''
        assert install_requires.lstrip() == expected_requires
        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []

    def test_install_requires_unordered_disallowed(self, tmpdir_cwd, env):
        """
        Packages that pass unordered install_requires sequences
        should be rejected as they produce non-deterministic
        builds. See #458.
        """
        req = 'install_requires={"fake-factory==0.5.2", "pytz"}'
        self._setup_script_with_requires(req)
        with pytest.raises(AssertionError):
            self._run_egg_info_command(tmpdir_cwd, env)

    def test_extras_require_with_invalid_marker(self, tmpdir_cwd, env):
        tmpl = 'extras_require={{":{marker}": ["barbazquux"]}},'
        req = tmpl.format(marker=self.invalid_marker)
        self._setup_script_with_requires(req)
        with pytest.raises(AssertionError):
            self._run_egg_info_command(tmpdir_cwd, env)
        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []

    def test_extras_require_with_invalid_marker_in_req(self, tmpdir_cwd, env):
        tmpl = 'extras_require={{"extra": ["barbazquux; {marker}"]}},'
        req = tmpl.format(marker=self.invalid_marker)
        self._setup_script_with_requires(req)
        with pytest.raises(AssertionError):
            self._run_egg_info_command(tmpdir_cwd, env)
        assert glob.glob(os.path.join(env.paths['lib'], 'barbazquux*')) == []

    def test_provides_extra(self, tmpdir_cwd, env):
        self._setup_script_with_requires('extras_require={"foobar": ["barbazquux"]},')
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Provides-Extra: foobar' in pkg_info_lines
        assert 'Metadata-Version: 2.1' in pkg_info_lines

    def test_doesnt_provides_extra(self, tmpdir_cwd, env):
        self._setup_script_with_requires(
            '''install_requires=["spam ; python_version<'3.6'"]'''
        )
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_text = pkginfo_file.read()
        assert 'Provides-Extra:' not in pkg_info_text

    @pytest.mark.parametrize(
        "files, license_in_sources",
        [
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE
                              """
                    ),
                    'LICENSE': "Test license",
                },
                True,
            ),  # with license
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = INVALID_LICENSE
                              """
                    ),
                    'LICENSE': "Test license",
                },
                False,
            ),  # with an invalid license
            (
                {
                    'setup.cfg': DALS(
                        """
                              """
                    ),
                    'LICENSE': "Test license",
                },
                True,
            ),  # no license_file attribute, LICENSE auto-included
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE
                              """
                    ),
                    'MANIFEST.in': "exclude LICENSE",
                    'LICENSE': "Test license",
                },
                True,
            ),  # manifest is overwritten by license_file
            pytest.param(
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICEN[CS]E*
                              """
                    ),
                    'LICENSE': "Test license",
                },
                True,
                id="glob_pattern",
            ),
        ],
    )
    def test_setup_cfg_license_file(self, tmpdir_cwd, env, files, license_in_sources):
        self._create_project()
        path.build(files)

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')

        with open(os.path.join(egg_info_dir, 'SOURCES.txt')) as sources_file:
            sources_text = sources_file.read()

        if license_in_sources:
            assert 'LICENSE' in sources_text
        else:
            assert 'LICENSE' not in sources_text
            # for invalid license test
            assert 'INVALID_LICENSE' not in sources_text

    @pytest.mark.parametrize(
        "files, incl_licenses, excl_licenses",
        [
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license",
                },
                ['LICENSE-ABC', 'LICENSE-XYZ'],
                [],
            ),  # with licenses
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files = LICENSE-ABC, LICENSE-XYZ
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license",
                },
                ['LICENSE-ABC', 'LICENSE-XYZ'],
                [],
            ),  # with commas
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license",
                },
                ['LICENSE-ABC'],
                ['LICENSE-XYZ'],
            ),  # with one license
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files =
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license",
                },
                [],
                ['LICENSE-ABC', 'LICENSE-XYZ'],
            ),  # empty
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files = LICENSE-XYZ
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license",
                },
                ['LICENSE-XYZ'],
                ['LICENSE-ABC'],
            ),  # on same line
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  INVALID_LICENSE
                              """
                    ),
                    'LICENSE-ABC': "Test license",
                },
                ['LICENSE-ABC'],
                ['INVALID_LICENSE'],
            ),  # with an invalid license
            (
                {
                    'setup.cfg': DALS(
                        """
                              """
                    ),
                    'LICENSE': "Test license",
                },
                ['LICENSE'],
                [],
            ),  # no license_files attribute, LICENSE auto-included
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files = LICENSE
                              """
                    ),
                    'MANIFEST.in': "exclude LICENSE",
                    'LICENSE': "Test license",
                },
                ['LICENSE'],
                [],
            ),  # manifest is overwritten by license_files
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                              """
                    ),
                    'MANIFEST.in': "exclude LICENSE-XYZ",
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license"
                    # manifest is overwritten by license_files
                },
                ['LICENSE-ABC', 'LICENSE-XYZ'],
                [],
            ),
            pytest.param(
                {
                    'setup.cfg': "",
                    'LICENSE-ABC': "ABC license",
                    'COPYING-ABC': "ABC copying",
                    'NOTICE-ABC': "ABC notice",
                    'AUTHORS-ABC': "ABC authors",
                    'LICENCE-XYZ': "XYZ license",
                    'LICENSE': "License",
                    'INVALID-LICENSE': "Invalid license",
                },
                [
                    'LICENSE-ABC',
                    'COPYING-ABC',
                    'NOTICE-ABC',
                    'AUTHORS-ABC',
                    'LICENCE-XYZ',
                    'LICENSE',
                ],
                ['INVALID-LICENSE'],
                # ('LICEN[CS]E*', 'COPYING*', 'NOTICE*', 'AUTHORS*')
                id="default_glob_patterns",
            ),
            pytest.param(
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files =
                                  LICENSE*
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'NOTICE-XYZ': "XYZ notice",
                },
                ['LICENSE-ABC'],
                ['NOTICE-XYZ'],
                id="no_default_glob_patterns",
            ),
            pytest.param(
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_files =
                                  LICENSE-ABC
                                  LICENSE*
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                },
                ['LICENSE-ABC'],
                [],
                id="files_only_added_once",
            ),
        ],
    )
    def test_setup_cfg_license_files(
        self, tmpdir_cwd, env, files, incl_licenses, excl_licenses
    ):
        self._create_project()
        path.build(files)

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')

        with open(os.path.join(egg_info_dir, 'SOURCES.txt')) as sources_file:
            sources_lines = list(line.strip() for line in sources_file)

        for lf in incl_licenses:
            assert sources_lines.count(lf) == 1

        for lf in excl_licenses:
            assert sources_lines.count(lf) == 0

    @pytest.mark.parametrize(
        "files, incl_licenses, excl_licenses",
        [
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file =
                              license_files =
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license",
                },
                [],
                ['LICENSE-ABC', 'LICENSE-XYZ'],
            ),  # both empty
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-XYZ': "XYZ license"
                    # license_file is still singular
                },
                [],
                ['LICENSE-ABC', 'LICENSE-XYZ'],
            ),
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-XYZ
                                  LICENSE-PQR
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-PQR': "PQR license",
                    'LICENSE-XYZ': "XYZ license",
                },
                ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'],
                [],
            ),  # combined
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-ABC
                                  LICENSE-XYZ
                                  LICENSE-PQR
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-PQR': "PQR license",
                    'LICENSE-XYZ': "XYZ license"
                    # duplicate license
                },
                ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'],
                [],
            ),
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-XYZ
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-PQR': "PQR license",
                    'LICENSE-XYZ': "XYZ license"
                    # combined subset
                },
                ['LICENSE-ABC', 'LICENSE-XYZ'],
                ['LICENSE-PQR'],
            ),
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                  LICENSE-XYZ
                                  LICENSE-PQR
                              """
                    ),
                    'LICENSE-PQR': "Test license"
                    # with invalid licenses
                },
                ['LICENSE-PQR'],
                ['LICENSE-ABC', 'LICENSE-XYZ'],
            ),
            (
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE-ABC
                              license_files =
                                LICENSE-PQR
                                LICENSE-XYZ
                              """
                    ),
                    'MANIFEST.in': "exclude LICENSE-ABC\nexclude LICENSE-PQR",
                    'LICENSE-ABC': "ABC license",
                    'LICENSE-PQR': "PQR license",
                    'LICENSE-XYZ': "XYZ license"
                    # manifest is overwritten
                },
                ['LICENSE-ABC', 'LICENSE-PQR', 'LICENSE-XYZ'],
                [],
            ),
            pytest.param(
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE*
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'NOTICE-XYZ': "XYZ notice",
                },
                ['LICENSE-ABC'],
                ['NOTICE-XYZ'],
                id="no_default_glob_patterns",
            ),
            pytest.param(
                {
                    'setup.cfg': DALS(
                        """
                              [metadata]
                              license_file = LICENSE*
                              license_files =
                                NOTICE*
                              """
                    ),
                    'LICENSE-ABC': "ABC license",
                    'NOTICE-ABC': "ABC notice",
                    'AUTHORS-ABC': "ABC authors",
                },
                ['LICENSE-ABC', 'NOTICE-ABC'],
                ['AUTHORS-ABC'],
                id="combined_glob_patterrns",
            ),
        ],
    )
    def test_setup_cfg_license_file_license_files(
        self, tmpdir_cwd, env, files, incl_licenses, excl_licenses
    ):
        self._create_project()
        path.build(files)

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')

        with open(os.path.join(egg_info_dir, 'SOURCES.txt')) as sources_file:
            sources_lines = list(line.strip() for line in sources_file)

        for lf in incl_licenses:
            assert sources_lines.count(lf) == 1

        for lf in excl_licenses:
            assert sources_lines.count(lf) == 0

    def test_license_file_attr_pkg_info(self, tmpdir_cwd, env):
        """All matched license files should have a corresponding License-File."""
        self._create_project()
        path.build(
            {
                "setup.cfg": DALS(
                    """
                              [metadata]
                              license_files =
                                  NOTICE*
                                  LICENSE*
                              """
                ),
                "LICENSE-ABC": "ABC license",
                "LICENSE-XYZ": "XYZ license",
                "NOTICE": "included",
                "IGNORE": "not include",
            }
        )

        environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        license_file_lines = [
            line for line in pkg_info_lines if line.startswith('License-File:')
        ]

        # Only 'NOTICE', LICENSE-ABC', and 'LICENSE-XYZ' should have been matched
        # Also assert that order from license_files is keeped
        assert "License-File: NOTICE" == license_file_lines[0]
        assert "License-File: LICENSE-ABC" in license_file_lines[1:]
        assert "License-File: LICENSE-XYZ" in license_file_lines[1:]

    def test_metadata_version(self, tmpdir_cwd, env):
        """Make sure latest metadata version is used by default."""
        self._setup_script_with_requires("")
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        # Update metadata version if changed
        assert self._extract_mv_version(pkg_info_lines) == (2, 1)

    def test_long_description_content_type(self, tmpdir_cwd, env):
        # Test that specifying a `long_description_content_type` keyword arg to
        # the `setup` function results in writing a `Description-Content-Type`
        # line to the `PKG-INFO` file in the `.egg-info`
        # directory.
        # `Description-Content-Type` is described at
        # https://github.com/pypa/python-packaging-user-guide/pull/258

        self._setup_script_with_requires(
            """long_description_content_type='text/markdown',"""
        )
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        expected_line = 'Description-Content-Type: text/markdown'
        assert expected_line in pkg_info_lines
        assert 'Metadata-Version: 2.1' in pkg_info_lines

    def test_long_description(self, tmpdir_cwd, env):
        # Test that specifying `long_description` and `long_description_content_type`
        # keyword args to the `setup` function results in writing
        # the description in the message payload of the `PKG-INFO` file
        # in the `.egg-info` directory.
        self._setup_script_with_requires(
            "long_description='This is a long description\\nover multiple lines',"
            "long_description_content_type='text/markdown',"
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Metadata-Version: 2.1' in pkg_info_lines
        assert '' == pkg_info_lines[-1]  # last line should be empty
        long_desc_lines = pkg_info_lines[pkg_info_lines.index('') :]
        assert 'This is a long description' in long_desc_lines
        assert 'over multiple lines' in long_desc_lines

    def test_project_urls(self, tmpdir_cwd, env):
        # Test that specifying a `project_urls` dict to the `setup`
        # function results in writing multiple `Project-URL` lines to
        # the `PKG-INFO` file in the `.egg-info`
        # directory.
        # `Project-URL` is described at https://packaging.python.org
        #     /specifications/core-metadata/#project-url-multiple-use

        self._setup_script_with_requires(
            """project_urls={
                'Link One': 'https://example.com/one/',
                'Link Two': 'https://example.com/two/',
                },"""
        )
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        expected_line = 'Project-URL: Link One, https://example.com/one/'
        assert expected_line in pkg_info_lines
        expected_line = 'Project-URL: Link Two, https://example.com/two/'
        assert expected_line in pkg_info_lines
        assert self._extract_mv_version(pkg_info_lines) >= (1, 2)

    def test_license(self, tmpdir_cwd, env):
        """Test single line license."""
        self._setup_script_with_requires("license='MIT',")
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'License: MIT' in pkg_info_lines

    def test_license_escape(self, tmpdir_cwd, env):
        """Test license is escaped correctly if longer than one line."""
        self._setup_script_with_requires(
            "license='This is a long license text \\nover multiple lines',"
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')

        assert 'License: This is a long license text ' in pkg_info_lines
        assert '        over multiple lines' in pkg_info_lines
        assert 'text \n        over multiple' in '\n'.join(pkg_info_lines)

    def test_python_requires_egg_info(self, tmpdir_cwd, env):
        self._setup_script_with_requires("""python_requires='>=2.7.12',""")
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        code, data = environment.run_setup_py(
            cmd=['egg_info'],
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Requires-Python: >=2.7.12' in pkg_info_lines
        assert self._extract_mv_version(pkg_info_lines) >= (1, 2)

    def test_manifest_maker_warning_suppression(self):
        fixtures = [
            "standard file not found: should have one of foo.py, bar.py",
            "standard file 'setup.py' not found",
        ]

        for msg in fixtures:
            assert manifest_maker._should_suppress_warning(msg)

    def test_egg_info_includes_setup_py(self, tmpdir_cwd):
        self._create_project()
        dist = Distribution({"name": "foo", "version": "0.0.1"})
        dist.script_name = "non_setup.py"
        egg_info_instance = egg_info(dist)
        egg_info_instance.finalize_options()
        egg_info_instance.run()

        assert 'setup.py' in egg_info_instance.filelist.files

        with open(egg_info_instance.egg_info + "/SOURCES.txt") as f:
            sources = f.read().split('\n')
            assert 'setup.py' in sources

    def _run_egg_info_command(self, tmpdir_cwd, env, cmd=None, output=None):
        environ = os.environ.copy().update(
            HOME=env.paths['home'],
        )
        if cmd is None:
            cmd = [
                'egg_info',
            ]
        code, data = environment.run_setup_py(
            cmd=cmd,
            pypath=os.pathsep.join([env.paths['lib'], str(tmpdir_cwd)]),
            data_stream=1,
            env=environ,
        )
        assert not code, data

        if output:
            assert output in data

    def test_egg_info_tag_only_once(self, tmpdir_cwd, env):
        self._create_project()
        path.build(
            {
                'setup.cfg': DALS(
                    """
                              [egg_info]
                              tag_build = dev
                              tag_date = 0
                              tag_svn_revision = 0
                              """
                ),
            }
        )
        self._run_egg_info_command(tmpdir_cwd, env)
        egg_info_dir = os.path.join('.', 'foo.egg-info')
        with open(os.path.join(egg_info_dir, 'PKG-INFO')) as pkginfo_file:
            pkg_info_lines = pkginfo_file.read().split('\n')
        assert 'Version: 0.0.0.dev0' in pkg_info_lines


class TestWriteEntries:
    def test_invalid_entry_point(self, tmpdir_cwd, env):
        dist = Distribution({"name": "foo", "version": "0.0.1"})
        dist.entry_points = {"foo": "foo = invalid-identifier:foo"}
        cmd = dist.get_command_obj("egg_info")
        expected_msg = r"Problems to parse .*invalid-identifier.*"
        with pytest.raises(errors.OptionError, match=expected_msg) as ex:
            write_entries(cmd, "entry_points", "entry_points.txt")
            assert "ensure entry-point follows the spec" in ex.value.args[0]

    def test_valid_entry_point(self, tmpdir_cwd, env):
        dist = Distribution({"name": "foo", "version": "0.0.1"})
        dist.entry_points = {
            "abc": "foo = bar:baz",
            "def": ["faa = bor:boz"],
        }
        cmd = dist.get_command_obj("egg_info")
        write_entries(cmd, "entry_points", "entry_points.txt")
        content = Path("entry_points.txt").read_text(encoding="utf-8")
        assert "[abc]\nfoo = bar:baz\n" in content
        assert "[def]\nfaa = bor:boz\n" in content
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_extern.py0000644000175100001730000000073114467657412021754 0ustar00runnerdockerimport importlib
import pickle

from setuptools import Distribution
from setuptools.extern import ordered_set


def test_reimport_extern():
    ordered_set2 = importlib.import_module(ordered_set.__name__)
    assert ordered_set is ordered_set2


def test_orderedset_pickle_roundtrip():
    o1 = ordered_set.OrderedSet([1, 2, 5])
    o2 = pickle.loads(pickle.dumps(o1))
    assert o1 == o2


def test_distribution_picklable():
    pickle.loads(pickle.dumps(Distribution()))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_find_packages.py0000644000175100001730000002041314467657412023224 0ustar00runnerdocker"""Tests for automatic package discovery"""
import os
import sys
import shutil
import tempfile
import platform

import pytest

from setuptools import find_packages
from setuptools import find_namespace_packages
from setuptools.discovery import FlatLayoutPackageFinder


# modeled after CPython's test.support.can_symlink
def can_symlink():
    TESTFN = tempfile.mktemp()
    symlink_path = TESTFN + "can_symlink"
    try:
        os.symlink(TESTFN, symlink_path)
        can = True
    except (OSError, NotImplementedError, AttributeError):
        can = False
    else:
        os.remove(symlink_path)
    globals().update(can_symlink=lambda: can)
    return can


def has_symlink():
    bad_symlink = (
        # Windows symlink directory detection is broken on Python 3.2
        platform.system() == 'Windows'
        and sys.version_info[:2] == (3, 2)
    )
    return can_symlink() and not bad_symlink


class TestFindPackages:
    def setup_method(self, method):
        self.dist_dir = tempfile.mkdtemp()
        self._make_pkg_structure()

    def teardown_method(self, method):
        shutil.rmtree(self.dist_dir)

    def _make_pkg_structure(self):
        """Make basic package structure.

        dist/
            docs/
                conf.py
            pkg/
                __pycache__/
                nspkg/
                    mod.py
                subpkg/
                    assets/
                        asset
                    __init__.py
            setup.py

        """
        self.docs_dir = self._mkdir('docs', self.dist_dir)
        self._touch('conf.py', self.docs_dir)
        self.pkg_dir = self._mkdir('pkg', self.dist_dir)
        self._mkdir('__pycache__', self.pkg_dir)
        self.ns_pkg_dir = self._mkdir('nspkg', self.pkg_dir)
        self._touch('mod.py', self.ns_pkg_dir)
        self.sub_pkg_dir = self._mkdir('subpkg', self.pkg_dir)
        self.asset_dir = self._mkdir('assets', self.sub_pkg_dir)
        self._touch('asset', self.asset_dir)
        self._touch('__init__.py', self.sub_pkg_dir)
        self._touch('setup.py', self.dist_dir)

    def _mkdir(self, path, parent_dir=None):
        if parent_dir:
            path = os.path.join(parent_dir, path)
        os.mkdir(path)
        return path

    def _touch(self, path, dir_=None):
        if dir_:
            path = os.path.join(dir_, path)
        fp = open(path, 'w')
        fp.close()
        return path

    def test_regular_package(self):
        self._touch('__init__.py', self.pkg_dir)
        packages = find_packages(self.dist_dir)
        assert packages == ['pkg', 'pkg.subpkg']

    def test_exclude(self):
        self._touch('__init__.py', self.pkg_dir)
        packages = find_packages(self.dist_dir, exclude=('pkg.*',))
        assert packages == ['pkg']

    def test_exclude_recursive(self):
        """
        Excluding a parent package should not exclude child packages as well.
        """
        self._touch('__init__.py', self.pkg_dir)
        self._touch('__init__.py', self.sub_pkg_dir)
        packages = find_packages(self.dist_dir, exclude=('pkg',))
        assert packages == ['pkg.subpkg']

    def test_include_excludes_other(self):
        """
        If include is specified, other packages should be excluded.
        """
        self._touch('__init__.py', self.pkg_dir)
        alt_dir = self._mkdir('other_pkg', self.dist_dir)
        self._touch('__init__.py', alt_dir)
        packages = find_packages(self.dist_dir, include=['other_pkg'])
        assert packages == ['other_pkg']

    def test_dir_with_dot_is_skipped(self):
        shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
        data_dir = self._mkdir('some.data', self.pkg_dir)
        self._touch('__init__.py', data_dir)
        self._touch('file.dat', data_dir)
        packages = find_packages(self.dist_dir)
        assert 'pkg.some.data' not in packages

    def test_dir_with_packages_in_subdir_is_excluded(self):
        """
        Ensure that a package in a non-package such as build/pkg/__init__.py
        is excluded.
        """
        build_dir = self._mkdir('build', self.dist_dir)
        build_pkg_dir = self._mkdir('pkg', build_dir)
        self._touch('__init__.py', build_pkg_dir)
        packages = find_packages(self.dist_dir)
        assert 'build.pkg' not in packages

    @pytest.mark.skipif(not has_symlink(), reason='Symlink support required')
    def test_symlinked_packages_are_included(self):
        """
        A symbolically-linked directory should be treated like any other
        directory when matched as a package.

        Create a link from lpkg -> pkg.
        """
        self._touch('__init__.py', self.pkg_dir)
        linked_pkg = os.path.join(self.dist_dir, 'lpkg')
        os.symlink('pkg', linked_pkg)
        assert os.path.isdir(linked_pkg)
        packages = find_packages(self.dist_dir)
        assert 'lpkg' in packages

    def _assert_packages(self, actual, expected):
        assert set(actual) == set(expected)

    def test_pep420_ns_package(self):
        packages = find_namespace_packages(
            self.dist_dir, include=['pkg*'], exclude=['pkg.subpkg.assets']
        )
        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])

    def test_pep420_ns_package_no_includes(self):
        packages = find_namespace_packages(self.dist_dir, exclude=['pkg.subpkg.assets'])
        self._assert_packages(packages, ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg'])

    def test_pep420_ns_package_no_includes_or_excludes(self):
        packages = find_namespace_packages(self.dist_dir)
        expected = ['docs', 'pkg', 'pkg.nspkg', 'pkg.subpkg', 'pkg.subpkg.assets']
        self._assert_packages(packages, expected)

    def test_regular_package_with_nested_pep420_ns_packages(self):
        self._touch('__init__.py', self.pkg_dir)
        packages = find_namespace_packages(
            self.dist_dir, exclude=['docs', 'pkg.subpkg.assets']
        )
        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])

    def test_pep420_ns_package_no_non_package_dirs(self):
        shutil.rmtree(self.docs_dir)
        shutil.rmtree(os.path.join(self.dist_dir, 'pkg/subpkg/assets'))
        packages = find_namespace_packages(self.dist_dir)
        self._assert_packages(packages, ['pkg', 'pkg.nspkg', 'pkg.subpkg'])


class TestFlatLayoutPackageFinder:
    EXAMPLES = {
        "hidden-folders": (
            [".pkg/__init__.py", "pkg/__init__.py", "pkg/nested/file.txt"],
            ["pkg", "pkg.nested"],
        ),
        "private-packages": (
            ["_pkg/__init__.py", "pkg/_private/__init__.py"],
            ["pkg", "pkg._private"],
        ),
        "invalid-name": (
            ["invalid-pkg/__init__.py", "other.pkg/__init__.py", "yet,another/file.py"],
            [],
        ),
        "docs": (["pkg/__init__.py", "docs/conf.py", "docs/readme.rst"], ["pkg"]),
        "tests": (
            ["pkg/__init__.py", "tests/test_pkg.py", "tests/__init__.py"],
            ["pkg"],
        ),
        "examples": (
            [
                "pkg/__init__.py",
                "examples/__init__.py",
                "examples/file.py" "example/other_file.py",
                # Sub-packages should always be fine
                "pkg/example/__init__.py",
                "pkg/examples/__init__.py",
            ],
            ["pkg", "pkg.examples", "pkg.example"],
        ),
        "tool-specific": (
            [
                "htmlcov/index.html",
                "pkg/__init__.py",
                "tasks/__init__.py",
                "tasks/subpackage/__init__.py",
                "fabfile/__init__.py",
                "fabfile/subpackage/__init__.py",
                # Sub-packages should always be fine
                "pkg/tasks/__init__.py",
                "pkg/fabfile/__init__.py",
            ],
            ["pkg", "pkg.tasks", "pkg.fabfile"],
        ),
    }

    @pytest.mark.parametrize("example", EXAMPLES.keys())
    def test_unwanted_directories_not_included(self, tmp_path, example):
        files, expected_packages = self.EXAMPLES[example]
        ensure_files(tmp_path, files)
        found_packages = FlatLayoutPackageFinder.find(str(tmp_path))
        assert set(found_packages) == set(expected_packages)


def ensure_files(root_path, files):
    for file in files:
        path = root_path / file
        path.parent.mkdir(parents=True, exist_ok=True)
        path.touch()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_find_py_modules.py0000644000175100001730000000450314467657412023630 0ustar00runnerdocker"""Tests for automatic discovery of modules"""
import os

import pytest

from setuptools.discovery import FlatLayoutModuleFinder, ModuleFinder

from .test_find_packages import ensure_files, has_symlink


class TestModuleFinder:
    def find(self, path, *args, **kwargs):
        return set(ModuleFinder.find(str(path), *args, **kwargs))

    EXAMPLES = {
        # circumstance: (files, kwargs, expected_modules)
        "simple_folder": (
            ["file.py", "other.py"],
            {},  # kwargs
            ["file", "other"],
        ),
        "exclude": (
            ["file.py", "other.py"],
            {"exclude": ["f*"]},
            ["other"],
        ),
        "include": (
            ["file.py", "fole.py", "other.py"],
            {"include": ["f*"], "exclude": ["fo*"]},
            ["file"],
        ),
        "invalid-name": (["my-file.py", "other.file.py"], {}, []),
    }

    @pytest.mark.parametrize("example", EXAMPLES.keys())
    def test_finder(self, tmp_path, example):
        files, kwargs, expected_modules = self.EXAMPLES[example]
        ensure_files(tmp_path, files)
        assert self.find(tmp_path, **kwargs) == set(expected_modules)

    @pytest.mark.skipif(not has_symlink(), reason='Symlink support required')
    def test_symlinked_packages_are_included(self, tmp_path):
        src = "_myfiles/file.py"
        ensure_files(tmp_path, [src])
        os.symlink(tmp_path / src, tmp_path / "link.py")
        assert self.find(tmp_path) == {"link"}


class TestFlatLayoutModuleFinder:
    def find(self, path, *args, **kwargs):
        return set(FlatLayoutModuleFinder.find(str(path)))

    EXAMPLES = {
        # circumstance: (files, expected_modules)
        "hidden-files": ([".module.py"], []),
        "private-modules": (["_module.py"], []),
        "common-names": (
            ["setup.py", "conftest.py", "test.py", "tests.py", "example.py", "mod.py"],
            ["mod"],
        ),
        "tool-specific": (
            ["tasks.py", "fabfile.py", "noxfile.py", "dodo.py", "manage.py", "mod.py"],
            ["mod"],
        ),
    }

    @pytest.mark.parametrize("example", EXAMPLES.keys())
    def test_unwanted_files_not_included(self, tmp_path, example):
        files, expected_modules = self.EXAMPLES[example]
        ensure_files(tmp_path, files)
        assert self.find(tmp_path) == set(expected_modules)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_glob.py0000644000175100001730000000156114467657412021374 0ustar00runnerdockerimport pytest
from jaraco import path

from setuptools.glob import glob


@pytest.mark.parametrize(
    'tree, pattern, matches',
    (
        ('', b'', []),
        ('', '', []),
        (
            '''
     appveyor.yml
     CHANGES.rst
     LICENSE
     MANIFEST.in
     pyproject.toml
     README.rst
     setup.cfg
     setup.py
     ''',
            '*.rst',
            ('CHANGES.rst', 'README.rst'),
        ),
        (
            '''
     appveyor.yml
     CHANGES.rst
     LICENSE
     MANIFEST.in
     pyproject.toml
     README.rst
     setup.cfg
     setup.py
     ''',
            b'*.rst',
            (b'CHANGES.rst', b'README.rst'),
        ),
    ),
)
def test_glob(monkeypatch, tmpdir, tree, pattern, matches):
    monkeypatch.chdir(tmpdir)
    path.build({name: '' for name in tree.split()})
    assert list(sorted(glob(pattern))) == list(sorted(matches))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_install_scripts.py0000644000175100001730000000647714467657412023701 0ustar00runnerdocker"""install_scripts tests
"""

import io
import sys

import pytest

from setuptools.command.install_scripts import install_scripts
from setuptools.dist import Distribution
from . import contexts


class TestInstallScripts:
    settings = dict(
        name='foo',
        entry_points={'console_scripts': ['foo=foo:foo']},
        version='0.0',
    )
    unix_exe = '/usr/dummy-test-path/local/bin/python'
    unix_spaces_exe = '/usr/bin/env dummy-test-python'
    win32_exe = 'C:\\Dummy Test Path\\Program Files\\Python 3.6\\python.exe'

    def _run_install_scripts(self, install_dir, executable=None):
        dist = Distribution(self.settings)
        dist.script_name = 'setup.py'
        cmd = install_scripts(dist)
        cmd.install_dir = install_dir
        if executable is not None:
            bs = cmd.get_finalized_command('build_scripts')
            bs.executable = executable
        cmd.ensure_finalized()
        with contexts.quiet():
            cmd.run()

    @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
    def test_sys_executable_escaping_unix(self, tmpdir, monkeypatch):
        """
        Ensure that shebang is not quoted on Unix when getting the Python exe
        from sys.executable.
        """
        expected = '#!%s\n' % self.unix_exe
        monkeypatch.setattr('sys.executable', self.unix_exe)
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir))
            with io.open(str(tmpdir.join('foo')), 'r') as f:
                actual = f.readline()
        assert actual == expected

    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only')
    def test_sys_executable_escaping_win32(self, tmpdir, monkeypatch):
        """
        Ensure that shebang is quoted on Windows when getting the Python exe
        from sys.executable and it contains a space.
        """
        expected = '#!"%s"\n' % self.win32_exe
        monkeypatch.setattr('sys.executable', self.win32_exe)
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir))
            with io.open(str(tmpdir.join('foo-script.py')), 'r') as f:
                actual = f.readline()
        assert actual == expected

    @pytest.mark.skipif(sys.platform == 'win32', reason='non-Windows only')
    def test_executable_with_spaces_escaping_unix(self, tmpdir):
        """
        Ensure that shebang on Unix is not quoted, even when
        a value with spaces
        is specified using --executable.
        """
        expected = '#!%s\n' % self.unix_spaces_exe
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir), self.unix_spaces_exe)
            with io.open(str(tmpdir.join('foo')), 'r') as f:
                actual = f.readline()
        assert actual == expected

    @pytest.mark.skipif(sys.platform != 'win32', reason='Windows only')
    def test_executable_arg_escaping_win32(self, tmpdir):
        """
        Ensure that shebang on Windows is quoted when
        getting a path with spaces
        from --executable, that is itself properly quoted.
        """
        expected = '#!"%s"\n' % self.win32_exe
        with tmpdir.as_cwd():
            self._run_install_scripts(str(tmpdir), '"' + self.win32_exe + '"')
            with io.open(str(tmpdir.join('foo-script.py')), 'r') as f:
                actual = f.readline()
        assert actual == expected
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_integration.py0000644000175100001730000000665314467657412023003 0ustar00runnerdocker"""Run some integration tests.

Try to install a few packages.
"""

import glob
import os
import sys
import urllib.request

import pytest

from setuptools.command.easy_install import easy_install
from setuptools.command import easy_install as easy_install_pkg
from setuptools.dist import Distribution


pytestmark = pytest.mark.skipif(
    'platform.python_implementation() == "PyPy" and ' 'platform.system() == "Windows"',
    reason="pypa/setuptools#2496",
)


def setup_module(module):
    packages = 'stevedore', 'virtualenvwrapper', 'pbr', 'novaclient'
    for pkg in packages:
        try:
            __import__(pkg)
            tmpl = "Integration tests cannot run when {pkg} is installed"
            pytest.skip(tmpl.format(**locals()))
        except ImportError:
            pass

    try:
        urllib.request.urlopen('https://pypi.python.org/pypi')
    except Exception as exc:
        pytest.skip(str(exc))


@pytest.fixture
def install_context(request, tmpdir, monkeypatch):
    """Fixture to set up temporary installation directory."""
    # Save old values so we can restore them.
    new_cwd = tmpdir.mkdir('cwd')
    user_base = tmpdir.mkdir('user_base')
    user_site = tmpdir.mkdir('user_site')
    install_dir = tmpdir.mkdir('install_dir')

    def fin():
        # undo the monkeypatch, particularly needed under
        # windows because of kept handle on cwd
        monkeypatch.undo()
        new_cwd.remove()
        user_base.remove()
        user_site.remove()
        install_dir.remove()

    request.addfinalizer(fin)

    # Change the environment and site settings to control where the
    # files are installed and ensure we do not overwrite anything.
    monkeypatch.chdir(new_cwd)
    monkeypatch.setattr(easy_install_pkg, '__file__', user_site.strpath)
    monkeypatch.setattr('site.USER_BASE', user_base.strpath)
    monkeypatch.setattr('site.USER_SITE', user_site.strpath)
    monkeypatch.setattr('sys.path', sys.path + [install_dir.strpath])
    monkeypatch.setenv(str('PYTHONPATH'), str(os.path.pathsep.join(sys.path)))

    # Set up the command for performing the installation.
    dist = Distribution()
    cmd = easy_install(dist)
    cmd.install_dir = install_dir.strpath
    return cmd


def _install_one(requirement, cmd, pkgname, modulename):
    cmd.args = [requirement]
    cmd.ensure_finalized()
    cmd.run()
    target = cmd.install_dir
    dest_path = glob.glob(os.path.join(target, pkgname + '*.egg'))
    assert dest_path
    assert os.path.exists(os.path.join(dest_path[0], pkgname, modulename))


def test_stevedore(install_context):
    _install_one('stevedore', install_context, 'stevedore', 'extension.py')


@pytest.mark.xfail
def test_virtualenvwrapper(install_context):
    _install_one(
        'virtualenvwrapper', install_context, 'virtualenvwrapper', 'hook_loader.py'
    )


def test_pbr(install_context):
    _install_one('pbr', install_context, 'pbr', 'core.py')


@pytest.mark.xfail
def test_python_novaclient(install_context):
    _install_one('python-novaclient', install_context, 'novaclient', 'base.py')


def test_pyuri(install_context):
    """
    Install the pyuri package (version 0.3.1 at the time of writing).

    This is also a regression test for issue #1016.
    """
    _install_one('pyuri', install_context, 'pyuri', 'uri.py')

    pyuri = install_context.installed_projects['pyuri']

    # The package data should be installed.
    assert os.path.exists(os.path.join(pyuri.location, 'pyuri', 'uri.regex'))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_logging.py0000644000175100001730000000306114467657412022074 0ustar00runnerdockerimport inspect
import logging
import os

import pytest


setup_py = """\
from setuptools import setup

setup(
    name="test_logging",
    version="0.0"
)
"""


@pytest.mark.parametrize(
    "flag, expected_level", [("--dry-run", "INFO"), ("--verbose", "DEBUG")]
)
def test_verbosity_level(tmp_path, monkeypatch, flag, expected_level):
    """Make sure the correct verbosity level is set (issue #3038)"""
    import setuptools  # noqa: F401  # import setuptools to monkeypatch distutils
    import distutils  # <- load distutils after all the patches take place

    logger = logging.Logger(__name__)
    monkeypatch.setattr(logging, "root", logger)
    unset_log_level = logger.getEffectiveLevel()
    assert logging.getLevelName(unset_log_level) == "NOTSET"

    setup_script = tmp_path / "setup.py"
    setup_script.write_text(setup_py)
    dist = distutils.core.run_setup(setup_script, stop_after="init")
    dist.script_args = [flag, "sdist"]
    dist.parse_command_line()  # <- where the log level is set
    log_level = logger.getEffectiveLevel()
    log_level_name = logging.getLevelName(log_level)
    assert log_level_name == expected_level


def test_patching_does_not_cause_problems():
    # Ensure `dist.log` is only patched if necessary

    import setuptools.logging
    from distutils import dist

    setuptools.logging.configure()

    if os.getenv("SETUPTOOLS_USE_DISTUTILS", "local").lower() == "local":
        # Modern logging infra, no problematic patching.
        assert isinstance(dist.log, logging.Logger)
    else:
        assert inspect.ismodule(dist.log)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_manifest.py0000644000175100001730000004476014467657412022267 0ustar00runnerdocker"""sdist tests"""

import contextlib
import os
import shutil
import sys
import tempfile
import itertools
import io
import logging
from distutils import log
from distutils.errors import DistutilsTemplateError

from setuptools.command.egg_info import FileList, egg_info, translate_pattern
from setuptools.dist import Distribution
from setuptools.tests.textwrap import DALS

import pytest


IS_PYPY = '__pypy__' in sys.builtin_module_names


def make_local_path(s):
    """Converts '/' in a string to os.sep"""
    return s.replace('/', os.sep)


SETUP_ATTRS = {
    'name': 'app',
    'version': '0.0',
    'packages': ['app'],
}

SETUP_PY = (
    """\
from setuptools import setup

setup(**%r)
"""
    % SETUP_ATTRS
)


@contextlib.contextmanager
def quiet():
    old_stdout, old_stderr = sys.stdout, sys.stderr
    sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
    try:
        yield
    finally:
        sys.stdout, sys.stderr = old_stdout, old_stderr


def touch(filename):
    open(filename, 'w').close()


# The set of files always in the manifest, including all files in the
# .egg-info directory
default_files = frozenset(
    map(
        make_local_path,
        [
            'README.rst',
            'MANIFEST.in',
            'setup.py',
            'app.egg-info/PKG-INFO',
            'app.egg-info/SOURCES.txt',
            'app.egg-info/dependency_links.txt',
            'app.egg-info/top_level.txt',
            'app/__init__.py',
        ],
    )
)


translate_specs = [
    ('foo', ['foo'], ['bar', 'foobar']),
    ('foo/bar', ['foo/bar'], ['foo/bar/baz', './foo/bar', 'foo']),
    # Glob matching
    ('*.txt', ['foo.txt', 'bar.txt'], ['foo/foo.txt']),
    ('dir/*.txt', ['dir/foo.txt', 'dir/bar.txt', 'dir/.txt'], ['notdir/foo.txt']),
    ('*/*.py', ['bin/start.py'], []),
    ('docs/page-?.txt', ['docs/page-9.txt'], ['docs/page-10.txt']),
    # Globstars change what they mean depending upon where they are
    (
        'foo/**/bar',
        ['foo/bing/bar', 'foo/bing/bang/bar', 'foo/bar'],
        ['foo/abar'],
    ),
    (
        'foo/**',
        ['foo/bar/bing.py', 'foo/x'],
        ['/foo/x'],
    ),
    (
        '**',
        ['x', 'abc/xyz', '@nything'],
        [],
    ),
    # Character classes
    (
        'pre[one]post',
        ['preopost', 'prenpost', 'preepost'],
        ['prepost', 'preonepost'],
    ),
    (
        'hello[!one]world',
        ['helloxworld', 'helloyworld'],
        ['hellooworld', 'helloworld', 'hellooneworld'],
    ),
    (
        '[]one].txt',
        ['o.txt', '].txt', 'e.txt'],
        ['one].txt'],
    ),
    (
        'foo[!]one]bar',
        ['fooybar'],
        ['foo]bar', 'fooobar', 'fooebar'],
    ),
]
"""
A spec of inputs for 'translate_pattern' and matches and mismatches
for that input.
"""

match_params = itertools.chain.from_iterable(
    zip(itertools.repeat(pattern), matches)
    for pattern, matches, mismatches in translate_specs
)


@pytest.fixture(params=match_params)
def pattern_match(request):
    return map(make_local_path, request.param)


mismatch_params = itertools.chain.from_iterable(
    zip(itertools.repeat(pattern), mismatches)
    for pattern, matches, mismatches in translate_specs
)


@pytest.fixture(params=mismatch_params)
def pattern_mismatch(request):
    return map(make_local_path, request.param)


def test_translated_pattern_match(pattern_match):
    pattern, target = pattern_match
    assert translate_pattern(pattern).match(target)


def test_translated_pattern_mismatch(pattern_mismatch):
    pattern, target = pattern_mismatch
    assert not translate_pattern(pattern).match(target)


class TempDirTestCase:
    def setup_method(self, method):
        self.temp_dir = tempfile.mkdtemp()
        self.old_cwd = os.getcwd()
        os.chdir(self.temp_dir)

    def teardown_method(self, method):
        os.chdir(self.old_cwd)
        shutil.rmtree(self.temp_dir)


class TestManifestTest(TempDirTestCase):
    def setup_method(self, method):
        super(TestManifestTest, self).setup_method(method)

        f = open(os.path.join(self.temp_dir, 'setup.py'), 'w')
        f.write(SETUP_PY)
        f.close()
        """
        Create a file tree like:
        - LICENSE
        - README.rst
        - testing.rst
        - .hidden.rst
        - app/
            - __init__.py
            - a.txt
            - b.txt
            - c.rst
            - static/
                - app.js
                - app.js.map
                - app.css
                - app.css.map
        """

        for fname in ['README.rst', '.hidden.rst', 'testing.rst', 'LICENSE']:
            touch(os.path.join(self.temp_dir, fname))

        # Set up the rest of the test package
        test_pkg = os.path.join(self.temp_dir, 'app')
        os.mkdir(test_pkg)
        for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']:
            touch(os.path.join(test_pkg, fname))

        # Some compiled front-end assets to include
        static = os.path.join(test_pkg, 'static')
        os.mkdir(static)
        for fname in ['app.js', 'app.js.map', 'app.css', 'app.css.map']:
            touch(os.path.join(static, fname))

    def make_manifest(self, contents):
        """Write a MANIFEST.in."""
        with open(os.path.join(self.temp_dir, 'MANIFEST.in'), 'w') as f:
            f.write(DALS(contents))

    def get_files(self):
        """Run egg_info and get all the files to include, as a set"""
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = egg_info(dist)
        cmd.ensure_finalized()

        cmd.run()

        return set(cmd.filelist.files)

    def test_no_manifest(self):
        """Check a missing MANIFEST.in includes only the standard files."""
        assert (default_files - set(['MANIFEST.in'])) == self.get_files()

    def test_empty_files(self):
        """Check an empty MANIFEST.in includes only the standard files."""
        self.make_manifest("")
        assert default_files == self.get_files()

    def test_include(self):
        """Include extra rst files in the project root."""
        self.make_manifest("include *.rst")
        files = default_files | set(['testing.rst', '.hidden.rst'])
        assert files == self.get_files()

    def test_exclude(self):
        """Include everything in app/ except the text files"""
        ml = make_local_path
        self.make_manifest(
            """
            include app/*
            exclude app/*.txt
            """
        )
        files = default_files | set([ml('app/c.rst')])
        assert files == self.get_files()

    def test_include_multiple(self):
        """Include with multiple patterns."""
        ml = make_local_path
        self.make_manifest("include app/*.txt app/static/*")
        files = default_files | set(
            [
                ml('app/a.txt'),
                ml('app/b.txt'),
                ml('app/static/app.js'),
                ml('app/static/app.js.map'),
                ml('app/static/app.css'),
                ml('app/static/app.css.map'),
            ]
        )
        assert files == self.get_files()

    def test_graft(self):
        """Include the whole app/static/ directory."""
        ml = make_local_path
        self.make_manifest("graft app/static")
        files = default_files | set(
            [
                ml('app/static/app.js'),
                ml('app/static/app.js.map'),
                ml('app/static/app.css'),
                ml('app/static/app.css.map'),
            ]
        )
        assert files == self.get_files()

    def test_graft_glob_syntax(self):
        """Include the whole app/static/ directory."""
        ml = make_local_path
        self.make_manifest("graft */static")
        files = default_files | set(
            [
                ml('app/static/app.js'),
                ml('app/static/app.js.map'),
                ml('app/static/app.css'),
                ml('app/static/app.css.map'),
            ]
        )
        assert files == self.get_files()

    def test_graft_global_exclude(self):
        """Exclude all *.map files in the project."""
        ml = make_local_path
        self.make_manifest(
            """
            graft app/static
            global-exclude *.map
            """
        )
        files = default_files | set([ml('app/static/app.js'), ml('app/static/app.css')])
        assert files == self.get_files()

    def test_global_include(self):
        """Include all *.rst, *.js, and *.css files in the whole tree."""
        ml = make_local_path
        self.make_manifest(
            """
            global-include *.rst *.js *.css
            """
        )
        files = default_files | set(
            [
                '.hidden.rst',
                'testing.rst',
                ml('app/c.rst'),
                ml('app/static/app.js'),
                ml('app/static/app.css'),
            ]
        )
        assert files == self.get_files()

    def test_graft_prune(self):
        """Include all files in app/, except for the whole app/static/ dir."""
        ml = make_local_path
        self.make_manifest(
            """
            graft app
            prune app/static
            """
        )
        files = default_files | set([ml('app/a.txt'), ml('app/b.txt'), ml('app/c.rst')])
        assert files == self.get_files()


class TestFileListTest(TempDirTestCase):
    """
    A copy of the relevant bits of distutils/tests/test_filelist.py,
    to ensure setuptools' version of FileList keeps parity with distutils.
    """

    @pytest.fixture(autouse=os.getenv("SETUPTOOLS_USE_DISTUTILS") == "stdlib")
    def _compat_record_logs(self, monkeypatch, caplog):
        """Account for stdlib compatibility"""

        def _log(_logger, level, msg, args):
            exc = sys.exc_info()
            rec = logging.LogRecord("distutils", level, "", 0, msg, args, exc)
            caplog.records.append(rec)

        monkeypatch.setattr(log.Log, "_log", _log)

    def get_records(self, caplog, *levels):
        return [r for r in caplog.records if r.levelno in levels]

    def assertNoWarnings(self, caplog):
        assert self.get_records(caplog, log.WARN) == []
        caplog.clear()

    def assertWarnings(self, caplog):
        if IS_PYPY and not caplog.records:
            pytest.xfail("caplog checks may not work well in PyPy")
        else:
            assert len(self.get_records(caplog, log.WARN)) > 0
            caplog.clear()

    def make_files(self, files):
        for file in files:
            file = os.path.join(self.temp_dir, file)
            dirname, basename = os.path.split(file)
            os.makedirs(dirname, exist_ok=True)
            open(file, 'w').close()

    def test_process_template_line(self):
        # testing  all MANIFEST.in template patterns
        file_list = FileList()
        ml = make_local_path

        # simulated file list
        self.make_files(
            [
                'foo.tmp',
                'ok',
                'xo',
                'four.txt',
                'buildout.cfg',
                # filelist does not filter out VCS directories,
                # it's sdist that does
                ml('.hg/last-message.txt'),
                ml('global/one.txt'),
                ml('global/two.txt'),
                ml('global/files.x'),
                ml('global/here.tmp'),
                ml('f/o/f.oo'),
                ml('dir/graft-one'),
                ml('dir/dir2/graft2'),
                ml('dir3/ok'),
                ml('dir3/sub/ok.txt'),
            ]
        )

        MANIFEST_IN = DALS(
            """\
        include ok
        include xo
        exclude xo
        include foo.tmp
        include buildout.cfg
        global-include *.x
        global-include *.txt
        global-exclude *.tmp
        recursive-include f *.oo
        recursive-exclude global *.x
        graft dir
        prune dir3
        """
        )

        for line in MANIFEST_IN.split('\n'):
            if not line:
                continue
            file_list.process_template_line(line)

        wanted = [
            'buildout.cfg',
            'four.txt',
            'ok',
            ml('.hg/last-message.txt'),
            ml('dir/graft-one'),
            ml('dir/dir2/graft2'),
            ml('f/o/f.oo'),
            ml('global/one.txt'),
            ml('global/two.txt'),
        ]

        file_list.sort()
        assert file_list.files == wanted

    def test_exclude_pattern(self):
        # return False if no match
        file_list = FileList()
        assert not file_list.exclude_pattern('*.py')

        # return True if files match
        file_list = FileList()
        file_list.files = ['a.py', 'b.py']
        assert file_list.exclude_pattern('*.py')

        # test excludes
        file_list = FileList()
        file_list.files = ['a.py', 'a.txt']
        file_list.exclude_pattern('*.py')
        file_list.sort()
        assert file_list.files == ['a.txt']

    def test_include_pattern(self):
        # return False if no match
        file_list = FileList()
        self.make_files([])
        assert not file_list.include_pattern('*.py')

        # return True if files match
        file_list = FileList()
        self.make_files(['a.py', 'b.txt'])
        assert file_list.include_pattern('*.py')

        # test * matches all files
        file_list = FileList()
        self.make_files(['a.py', 'b.txt'])
        file_list.include_pattern('*')
        file_list.sort()
        assert file_list.files == ['a.py', 'b.txt']

    def test_process_template_line_invalid(self):
        # invalid lines
        file_list = FileList()
        for action in (
            'include',
            'exclude',
            'global-include',
            'global-exclude',
            'recursive-include',
            'recursive-exclude',
            'graft',
            'prune',
            'blarg',
        ):
            try:
                file_list.process_template_line(action)
            except DistutilsTemplateError:
                pass
            except Exception:
                assert False, "Incorrect error thrown"
            else:
                assert False, "Should have thrown an error"

    def test_include(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # include
        file_list = FileList()
        self.make_files(['a.py', 'b.txt', ml('d/c.py')])

        file_list.process_template_line('include *.py')
        file_list.sort()
        assert file_list.files == ['a.py']
        self.assertNoWarnings(caplog)

        file_list.process_template_line('include *.rb')
        file_list.sort()
        assert file_list.files == ['a.py']
        self.assertWarnings(caplog)

    def test_exclude(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', ml('d/c.py')]

        file_list.process_template_line('exclude *.py')
        file_list.sort()
        assert file_list.files == ['b.txt', ml('d/c.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('exclude *.rb')
        file_list.sort()
        assert file_list.files == ['b.txt', ml('d/c.py')]
        self.assertWarnings(caplog)

    def test_global_include(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # global-include
        file_list = FileList()
        self.make_files(['a.py', 'b.txt', ml('d/c.py')])

        file_list.process_template_line('global-include *.py')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('global-include *.rb')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.py')]
        self.assertWarnings(caplog)

    def test_global_exclude(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # global-exclude
        file_list = FileList()
        file_list.files = ['a.py', 'b.txt', ml('d/c.py')]

        file_list.process_template_line('global-exclude *.py')
        file_list.sort()
        assert file_list.files == ['b.txt']
        self.assertNoWarnings(caplog)

        file_list.process_template_line('global-exclude *.rb')
        file_list.sort()
        assert file_list.files == ['b.txt']
        self.assertWarnings(caplog)

    def test_recursive_include(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # recursive-include
        file_list = FileList()
        self.make_files(['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')])

        file_list.process_template_line('recursive-include d *.py')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('recursive-include e *.py')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertWarnings(caplog)

    def test_recursive_exclude(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # recursive-exclude
        file_list = FileList()
        file_list.files = ['a.py', ml('d/b.py'), ml('d/c.txt'), ml('d/d/e.py')]

        file_list.process_template_line('recursive-exclude d *.py')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.txt')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('recursive-exclude e *.py')
        file_list.sort()
        assert file_list.files == ['a.py', ml('d/c.txt')]
        self.assertWarnings(caplog)

    def test_graft(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # graft
        file_list = FileList()
        self.make_files(['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')])

        file_list.process_template_line('graft d')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('graft e')
        file_list.sort()
        assert file_list.files == [ml('d/b.py'), ml('d/d/e.py')]
        self.assertWarnings(caplog)

    def test_prune(self, caplog):
        caplog.set_level(logging.DEBUG)
        ml = make_local_path
        # prune
        file_list = FileList()
        file_list.files = ['a.py', ml('d/b.py'), ml('d/d/e.py'), ml('f/f.py')]

        file_list.process_template_line('prune d')
        file_list.sort()
        assert file_list.files == ['a.py', ml('f/f.py')]
        self.assertNoWarnings(caplog)

        file_list.process_template_line('prune e')
        file_list.sort()
        assert file_list.files == ['a.py', ml('f/f.py')]
        self.assertWarnings(caplog)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_msvc14.py0000644000175100001730000000534114467657412021566 0ustar00runnerdocker"""
Tests for msvc support module (msvc14 unit tests).
"""

import os
from distutils.errors import DistutilsPlatformError
import pytest
import sys


@pytest.mark.skipif(sys.platform != "win32", reason="These tests are only for win32")
class TestMSVC14:
    """Python 3.8 "distutils/tests/test_msvccompiler.py" backport"""

    def test_no_compiler(self):
        import setuptools.msvc as _msvccompiler

        # makes sure query_vcvarsall raises
        # a DistutilsPlatformError if the compiler
        # is not found

        def _find_vcvarsall(plat_spec):
            return None, None

        old_find_vcvarsall = _msvccompiler._msvc14_find_vcvarsall
        _msvccompiler._msvc14_find_vcvarsall = _find_vcvarsall
        try:
            pytest.raises(
                DistutilsPlatformError,
                _msvccompiler._msvc14_get_vc_env,
                'wont find this version',
            )
        finally:
            _msvccompiler._msvc14_find_vcvarsall = old_find_vcvarsall

    def test_get_vc_env_unicode(self):
        import setuptools.msvc as _msvccompiler

        test_var = 'ṰḖṤṪ┅ṼẨṜ'
        test_value = '₃⁴₅'

        # Ensure we don't early exit from _get_vc_env
        old_distutils_use_sdk = os.environ.pop('DISTUTILS_USE_SDK', None)
        os.environ[test_var] = test_value
        try:
            env = _msvccompiler._msvc14_get_vc_env('x86')
            assert test_var.lower() in env
            assert test_value == env[test_var.lower()]
        finally:
            os.environ.pop(test_var)
            if old_distutils_use_sdk:
                os.environ['DISTUTILS_USE_SDK'] = old_distutils_use_sdk

    def test_get_vc2017(self):
        import setuptools.msvc as _msvccompiler

        # This function cannot be mocked, so pass it if we find VS 2017
        # and mark it skipped if we do not.
        version, path = _msvccompiler._msvc14_find_vc2017()
        if os.environ.get('APPVEYOR_BUILD_WORKER_IMAGE', '') in ['Visual Studio 2017']:
            assert version
        if version:
            assert version >= 15
            assert os.path.isdir(path)
        else:
            pytest.skip("VS 2017 is not installed")

    def test_get_vc2015(self):
        import setuptools.msvc as _msvccompiler

        # This function cannot be mocked, so pass it if we find VS 2015
        # and mark it skipped if we do not.
        version, path = _msvccompiler._msvc14_find_vc2015()
        if os.environ.get('APPVEYOR_BUILD_WORKER_IMAGE', '') in [
            'Visual Studio 2015',
            'Visual Studio 2017',
        ]:
            assert version
        if version:
            assert version >= 14
            assert os.path.isdir(path)
        else:
            pytest.skip("VS 2015 is not installed")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_namespaces.py0000644000175100001730000001112314467657412022563 0ustar00runnerdockerimport sys
import subprocess

import pytest

from . import namespaces
from setuptools.command import test


class TestNamespaces:
    @pytest.mark.skipif(
        sys.version_info < (3, 5),
        reason="Requires importlib.util.module_from_spec",
    )
    def test_mixed_site_and_non_site(self, tmpdir):
        """
        Installing two packages sharing the same namespace, one installed
        to a site dir and the other installed just to a path on PYTHONPATH
        should leave the namespace in tact and both packages reachable by
        import.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
        site_packages = tmpdir / 'site-packages'
        path_packages = tmpdir / 'path-packages'
        targets = site_packages, path_packages
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_A),
            '-t',
            str(site_packages),
        ]
        subprocess.check_call(install_cmd)
        namespaces.make_site_dir(site_packages)
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_B),
            '-t',
            str(path_packages),
        ]
        subprocess.check_call(install_cmd)
        try_import = [
            sys.executable,
            '-c',
            'import myns.pkgA; import myns.pkgB',
        ]
        with test.test.paths_on_pythonpath(map(str, targets)):
            subprocess.check_call(try_import)

    def test_pkg_resources_import(self, tmpdir):
        """
        Ensure that a namespace package doesn't break on import
        of pkg_resources.
        """
        pkg = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        target = tmpdir / 'packages'
        target.mkdir()
        install_cmd = [
            sys.executable,
            '-m',
            'pip',
            'install',
            '-t',
            str(target),
            str(pkg),
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(install_cmd)
        namespaces.make_site_dir(target)
        try_import = [
            sys.executable,
            '-c',
            'import pkg_resources',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(try_import)

    def test_namespace_package_installed_and_cwd(self, tmpdir):
        """
        Installing a namespace packages but also having it in the current
        working directory, only one version should take precedence.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        target = tmpdir / 'packages'
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_A),
            '-t',
            str(target),
        ]
        subprocess.check_call(install_cmd)
        namespaces.make_site_dir(target)

        # ensure that package imports and pkg_resources imports
        pkg_resources_imp = [
            sys.executable,
            '-c',
            'import pkg_resources; import myns.pkgA',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(pkg_resources_imp, cwd=str(pkg_A))

    def test_packages_in_the_same_namespace_installed_and_cwd(self, tmpdir):
        """
        Installing one namespace package and also have another in the same
        namespace in the current working directory, both of them must be
        importable.
        """
        pkg_A = namespaces.build_namespace_package(tmpdir, 'myns.pkgA')
        pkg_B = namespaces.build_namespace_package(tmpdir, 'myns.pkgB')
        target = tmpdir / 'packages'
        # use pip to install to the target directory
        install_cmd = [
            sys.executable,
            '-m',
            'pip.__main__',
            'install',
            str(pkg_A),
            '-t',
            str(target),
        ]
        subprocess.check_call(install_cmd)
        namespaces.make_site_dir(target)

        # ensure that all packages import and pkg_resources imports
        pkg_resources_imp = [
            sys.executable,
            '-c',
            'import pkg_resources; import myns.pkgA; import myns.pkgB',
        ]
        with test.test.paths_on_pythonpath([str(target)]):
            subprocess.check_call(pkg_resources_imp, cwd=str(pkg_B))
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_packageindex.py0000644000175100001730000002343614467657412023101 0ustar00runnerdockerimport sys
import os
import distutils.errors
import platform
import urllib.request
import urllib.error
import http.client
from unittest import mock

import pytest

import setuptools.package_index
from .textwrap import DALS


class TestPackageIndex:
    def test_regex(self):
        hash_url = 'http://other_url?:action=show_md5&'
        hash_url += 'digest=0123456789abcdef0123456789abcdef'
        doc = """
            Name
            (md5)
        """.lstrip().format(
            **locals()
        )
        assert setuptools.package_index.PYPI_MD5.match(doc)

    def test_bad_url_bad_port(self):
        index = setuptools.package_index.PackageIndex()
        url = 'http://127.0.0.1:0/nonesuch/test_package_index'
        try:
            v = index.open_url(url)
        except Exception as exc:
            assert url in str(exc)
        else:
            assert isinstance(v, urllib.error.HTTPError)

    def test_bad_url_typo(self):
        # issue 16
        # easy_install inquant.contentmirror.plone breaks because of a typo
        # in its home URL
        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))

        url = (
            'url:%20https://svn.plone.org/svn'
            '/collective/inquant.contentmirror.plone/trunk'
        )
        try:
            v = index.open_url(url)
        except Exception as exc:
            assert url in str(exc)
        else:
            assert isinstance(v, urllib.error.HTTPError)

    def test_bad_url_bad_status_line(self):
        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))

        def _urlopen(*args):
            raise http.client.BadStatusLine('line')

        index.opener = _urlopen
        url = 'http://example.com'
        try:
            index.open_url(url)
        except Exception as exc:
            assert 'line' in str(exc)
        else:
            raise AssertionError('Should have raise here!')

    def test_bad_url_double_scheme(self):
        """
        A bad URL with a double scheme should raise a DistutilsError.
        """
        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))

        # issue 20
        url = 'http://http://svn.pythonpaste.org/Paste/wphp/trunk'
        try:
            index.open_url(url)
        except distutils.errors.DistutilsError as error:
            msg = str(error)
            assert (
                'nonnumeric port' in msg
                or 'getaddrinfo failed' in msg
                or 'Name or service not known' in msg
            )
            return
        raise RuntimeError("Did not raise")

    def test_bad_url_screwy_href(self):
        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))

        # issue #160
        if sys.version_info[0] == 2 and sys.version_info[1] == 7:
            # this should not fail
            url = 'http://example.com'
            page = ''
            index.process_index(url, page)

    def test_url_ok(self):
        index = setuptools.package_index.PackageIndex(hosts=('www.example.com',))
        url = 'file:///tmp/test_package_index'
        assert index.url_ok(url, True)

    def test_parse_bdist_wininst(self):
        parse = setuptools.package_index.parse_bdist_wininst

        actual = parse('reportlab-2.5.win32-py2.4.exe')
        expected = 'reportlab-2.5', '2.4', 'win32'
        assert actual == expected

        actual = parse('reportlab-2.5.win32.exe')
        expected = 'reportlab-2.5', None, 'win32'
        assert actual == expected

        actual = parse('reportlab-2.5.win-amd64-py2.7.exe')
        expected = 'reportlab-2.5', '2.7', 'win-amd64'
        assert actual == expected

        actual = parse('reportlab-2.5.win-amd64.exe')
        expected = 'reportlab-2.5', None, 'win-amd64'
        assert actual == expected

    def test__vcs_split_rev_from_url(self):
        """
        Test the basic usage of _vcs_split_rev_from_url
        """
        vsrfu = setuptools.package_index.PackageIndex._vcs_split_rev_from_url
        url, rev = vsrfu('https://example.com/bar@2995')
        assert url == 'https://example.com/bar'
        assert rev == '2995'

    def test_local_index(self, tmpdir):
        """
        local_open should be able to read an index from the file system.
        """
        index_file = tmpdir / 'index.html'
        with index_file.open('w') as f:
            f.write('
content
')
        url = 'file:' + urllib.request.pathname2url(str(tmpdir)) + '/'
        res = setuptools.package_index.local_open(url)
        assert 'content' in res.read()

    def test_egg_fragment(self):
        """
        EGG fragments must comply to PEP 440
        """
        epoch = [
            '',
            '1!',
        ]
        releases = [
            '0',
            '0.0',
            '0.0.0',
        ]
        pre = [
            'a0',
            'b0',
            'rc0',
        ]
        post = ['.post0']
        dev = [
            '.dev0',
        ]
        local = [
            ('', ''),
            ('+ubuntu.0', '+ubuntu.0'),
            ('+ubuntu-0', '+ubuntu.0'),
            ('+ubuntu_0', '+ubuntu.0'),
        ]
        versions = [
            [''.join([e, r, p, loc]) for loc in locs]
            for e in epoch
            for r in releases
            for p in sum([pre, post, dev], [''])
            for locs in local
        ]
        for v, vc in versions:
            dists = list(
                setuptools.package_index.distros_for_url(
                    'http://example.com/example-foo.zip#egg=example-foo-' + v
                )
            )
            assert dists[0].version == ''
            assert dists[1].version == vc

    def test_download_git_with_rev(self, tmpdir):
        url = 'git+https://github.example/group/project@master#egg=foo'
        index = setuptools.package_index.PackageIndex()

        with mock.patch("os.system") as os_system_mock:
            result = index.download(url, str(tmpdir))

        os_system_mock.assert_called()

        expected_dir = str(tmpdir / 'project@master')
        expected = (
            'git clone --quiet ' 'https://github.example/group/project {expected_dir}'
        ).format(**locals())
        first_call_args = os_system_mock.call_args_list[0][0]
        assert first_call_args == (expected,)

        tmpl = 'git -C {expected_dir} checkout --quiet master'
        expected = tmpl.format(**locals())
        assert os_system_mock.call_args_list[1][0] == (expected,)
        assert result == expected_dir

    def test_download_git_no_rev(self, tmpdir):
        url = 'git+https://github.example/group/project#egg=foo'
        index = setuptools.package_index.PackageIndex()

        with mock.patch("os.system") as os_system_mock:
            result = index.download(url, str(tmpdir))

        os_system_mock.assert_called()

        expected_dir = str(tmpdir / 'project')
        expected = (
            'git clone --quiet ' 'https://github.example/group/project {expected_dir}'
        ).format(**locals())
        os_system_mock.assert_called_once_with(expected)

    def test_download_svn(self, tmpdir):
        url = 'svn+https://svn.example/project#egg=foo'
        index = setuptools.package_index.PackageIndex()

        msg = r".*SVN download is not supported.*"
        with pytest.raises(distutils.errors.DistutilsError, match=msg):
            index.download(url, str(tmpdir))


class TestContentCheckers:
    def test_md5(self):
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478'
        )
        checker.feed('You should probably not be using MD5'.encode('ascii'))
        assert checker.hash.hexdigest() == 'f12895fdffbd45007040d2e44df98478'
        assert checker.is_valid()

    def test_other_fragment(self):
        "Content checks should succeed silently if no hash is present"
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#something%20completely%20different'
        )
        checker.feed('anything'.encode('ascii'))
        assert checker.is_valid()

    def test_blank_md5(self):
        "Content checks should succeed if a hash is empty"
        checker = setuptools.package_index.HashChecker.from_url('http://foo/bar#md5=')
        checker.feed('anything'.encode('ascii'))
        assert checker.is_valid()

    def test_get_hash_name_md5(self):
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478'
        )
        assert checker.hash_name == 'md5'

    def test_report(self):
        checker = setuptools.package_index.HashChecker.from_url(
            'http://foo/bar#md5=f12895fdffbd45007040d2e44df98478'
        )
        rep = checker.report(lambda x: x, 'My message about %s')
        assert rep == 'My message about md5'


@pytest.fixture
def temp_home(tmpdir, monkeypatch):
    key = (
        'USERPROFILE'
        if platform.system() == 'Windows' and sys.version_info > (3, 8)
        else 'HOME'
    )

    monkeypatch.setitem(os.environ, key, str(tmpdir))
    return tmpdir


class TestPyPIConfig:
    def test_percent_in_password(self, temp_home):
        pypirc = temp_home / '.pypirc'
        pypirc.write(
            DALS(
                """
            [pypi]
            repository=https://pypi.org
            username=jaraco
            password=pity%
        """
            )
        )
        cfg = setuptools.package_index.PyPIConfig()
        cred = cfg.creds_by_repository['https://pypi.org']
        assert cred.username == 'jaraco'
        assert cred.password == 'pity%'


@pytest.mark.timeout(1)
def test_REL_DoS():
    """
    REL should not hang on a contrived attack string.
    """
    setuptools.package_index.REL.search('< rel=' + ' ' * 2**12)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_register.py0000644000175100001730000000100514467657412022266 0ustar00runnerdockerfrom setuptools.command.register import register
from setuptools.dist import Distribution
from setuptools.errors import RemovedCommandError

from unittest import mock

import pytest


class TestRegister:
    def test_register_exception(self):
        """Ensure that the register command has been properly removed."""
        dist = Distribution()
        dist.dist_files = [(mock.Mock(), mock.Mock(), mock.Mock())]

        cmd = register(dist)

        with pytest.raises(RemovedCommandError):
            cmd.run()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_sandbox.py0000644000175100001730000001020314467657412022100 0ustar00runnerdocker"""develop tests
"""
import os
import types

import pytest

import pkg_resources
import setuptools.sandbox


class TestSandbox:
    def test_devnull(self, tmpdir):
        with setuptools.sandbox.DirectorySandbox(str(tmpdir)):
            self._file_writer(os.devnull)

    @staticmethod
    def _file_writer(path):
        def do_write():
            with open(path, 'w') as f:
                f.write('xxx')

        return do_write

    def test_setup_py_with_BOM(self):
        """
        It should be possible to execute a setup.py with a Byte Order Mark
        """
        target = pkg_resources.resource_filename(__name__, 'script-with-bom.py')
        namespace = types.ModuleType('namespace')
        setuptools.sandbox._execfile(target, vars(namespace))
        assert namespace.result == 'passed'

    def test_setup_py_with_CRLF(self, tmpdir):
        setup_py = tmpdir / 'setup.py'
        with setup_py.open('wb') as stream:
            stream.write(b'"degenerate script"\r\n')
        setuptools.sandbox._execfile(str(setup_py), globals())


class TestExceptionSaver:
    def test_exception_trapped(self):
        with setuptools.sandbox.ExceptionSaver():
            raise ValueError("details")

    def test_exception_resumed(self):
        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            raise ValueError("details")

        with pytest.raises(ValueError) as caught:
            saved_exc.resume()

        assert isinstance(caught.value, ValueError)
        assert str(caught.value) == 'details'

    def test_exception_reconstructed(self):
        orig_exc = ValueError("details")

        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            raise orig_exc

        with pytest.raises(ValueError) as caught:
            saved_exc.resume()

        assert isinstance(caught.value, ValueError)
        assert caught.value is not orig_exc

    def test_no_exception_passes_quietly(self):
        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            pass

        saved_exc.resume()

    def test_unpickleable_exception(self):
        class CantPickleThis(Exception):
            "This Exception is unpickleable because it's not in globals"

            def __repr__(self):
                return 'CantPickleThis%r' % (self.args,)

        with setuptools.sandbox.ExceptionSaver() as saved_exc:
            raise CantPickleThis('detail')

        with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
            saved_exc.resume()

        assert str(caught.value) == "CantPickleThis('detail',)"

    def test_unpickleable_exception_when_hiding_setuptools(self):
        """
        As revealed in #440, an infinite recursion can occur if an unpickleable
        exception while setuptools is hidden. Ensure this doesn't happen.
        """

        class ExceptionUnderTest(Exception):
            """
            An unpickleable exception (not in globals).
            """

        with pytest.raises(setuptools.sandbox.UnpickleableException) as caught:
            with setuptools.sandbox.save_modules():
                setuptools.sandbox.hide_setuptools()
                raise ExceptionUnderTest()

        (msg,) = caught.value.args
        assert msg == 'ExceptionUnderTest()'

    def test_sandbox_violation_raised_hiding_setuptools(self, tmpdir):
        """
        When in a sandbox with setuptools hidden, a SandboxViolation
        should reflect a proper exception and not be wrapped in
        an UnpickleableException.
        """

        def write_file():
            "Trigger a SandboxViolation by writing outside the sandbox"
            with open('/etc/foo', 'w'):
                pass

        with pytest.raises(setuptools.sandbox.SandboxViolation) as caught:
            with setuptools.sandbox.save_modules():
                setuptools.sandbox.hide_setuptools()
                with setuptools.sandbox.DirectorySandbox(str(tmpdir)):
                    write_file()

        cmd, args, kwargs = caught.value.args
        assert cmd == 'open'
        assert args == ('/etc/foo', 'w')
        assert kwargs == {}

        msg = str(caught.value)
        assert 'open' in msg
        assert "('/etc/foo', 'w')" in msg
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_sdist.py0000644000175100001730000007205114467657412021601 0ustar00runnerdocker"""sdist tests"""

import os
import sys
import tempfile
import unicodedata
import contextlib
import io
import tarfile
import logging
import distutils
from inspect import cleandoc
from pathlib import Path
from unittest import mock

import pytest

from distutils.core import run_setup
from setuptools import Command
from setuptools._importlib import metadata
from setuptools import SetuptoolsDeprecationWarning
from setuptools.command.sdist import sdist
from setuptools.command.egg_info import manifest_maker
from setuptools.dist import Distribution
from setuptools.extension import Extension
from setuptools.tests import fail_on_ascii
from .text import Filenames

import jaraco.path


SETUP_ATTRS = {
    'name': 'sdist_test',
    'version': '0.0',
    'packages': ['sdist_test'],
    'package_data': {'sdist_test': ['*.txt']},
    'data_files': [("data", [os.path.join("d", "e.dat")])],
}

SETUP_PY = (
    """\
from setuptools import setup

setup(**%r)
"""
    % SETUP_ATTRS
)

EXTENSION = Extension(
    name="sdist_test.f",
    sources=[os.path.join("sdist_test", "f.c")],
    depends=[os.path.join("sdist_test", "f.h")],
)
EXTENSION_SOURCES = EXTENSION.sources + EXTENSION.depends


@contextlib.contextmanager
def quiet():
    old_stdout, old_stderr = sys.stdout, sys.stderr
    sys.stdout, sys.stderr = io.StringIO(), io.StringIO()
    try:
        yield
    finally:
        sys.stdout, sys.stderr = old_stdout, old_stderr


# Convert to POSIX path
def posix(path):
    if not isinstance(path, str):
        return path.replace(os.sep.encode('ascii'), b'/')
    else:
        return path.replace(os.sep, '/')


# HFS Plus uses decomposed UTF-8
def decompose(path):
    if isinstance(path, str):
        return unicodedata.normalize('NFD', path)
    try:
        path = path.decode('utf-8')
        path = unicodedata.normalize('NFD', path)
        path = path.encode('utf-8')
    except UnicodeError:
        pass  # Not UTF-8
    return path


def read_all_bytes(filename):
    with io.open(filename, 'rb') as fp:
        return fp.read()


def latin1_fail():
    try:
        desc, filename = tempfile.mkstemp(suffix=Filenames.latin_1)
        os.close(desc)
        os.remove(filename)
    except Exception:
        return True


fail_on_latin1_encoded_filenames = pytest.mark.xfail(
    latin1_fail(),
    reason="System does not support latin-1 filenames",
)


skip_under_xdist = pytest.mark.skipif(
    "os.environ.get('PYTEST_XDIST_WORKER')",
    reason="pytest-dev/pytest-xdist#843",
)
skip_under_stdlib_distutils = pytest.mark.skipif(
    not distutils.__package__.startswith('setuptools'),
    reason="the test is not supported with stdlib distutils",
)


def touch(path):
    if isinstance(path, str):
        path = Path(path)
    path.write_text('', encoding='utf-8')
    return path


def symlink_or_skip_test(src, dst):
    try:
        os.symlink(src, dst)
        return dst
    except (OSError, NotImplementedError):
        pytest.skip("symlink not supported in OS")


class TestSdistTest:
    @pytest.fixture(autouse=True)
    def source_dir(self, tmpdir):
        tmpdir = tmpdir / "project_root"
        tmpdir.mkdir()

        (tmpdir / 'setup.py').write_text(SETUP_PY, encoding='utf-8')

        # Set up the rest of the test package
        test_pkg = tmpdir / 'sdist_test'
        test_pkg.mkdir()
        data_folder = tmpdir / 'd'
        data_folder.mkdir()
        # *.rst was not included in package_data, so c.rst should not be
        # automatically added to the manifest when not under version control
        for fname in ['__init__.py', 'a.txt', 'b.txt', 'c.rst']:
            touch(test_pkg / fname)
        touch(data_folder / 'e.dat')
        # C sources are not included by default, but they will be,
        # if an extension module uses them as sources or depends
        for fname in EXTENSION_SOURCES:
            touch(tmpdir / fname)

        with tmpdir.as_cwd():
            yield tmpdir

    def assert_package_data_in_manifest(self, cmd):
        manifest = cmd.filelist.files
        assert os.path.join('sdist_test', 'a.txt') in manifest
        assert os.path.join('sdist_test', 'b.txt') in manifest
        assert os.path.join('sdist_test', 'c.rst') not in manifest
        assert os.path.join('d', 'e.dat') in manifest

    def setup_with_extension(self):
        setup_attrs = {**SETUP_ATTRS, 'ext_modules': [EXTENSION]}

        dist = Distribution(setup_attrs)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        return cmd

    def test_package_data_in_sdist(self):
        """Regression test for pull request #4: ensures that files listed in
        package_data are included in the manifest even if they're not added to
        version control.
        """

        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        self.assert_package_data_in_manifest(cmd)

    def test_package_data_and_include_package_data_in_sdist(self):
        """
        Ensure package_data and include_package_data work
        together.
        """
        setup_attrs = {**SETUP_ATTRS, 'include_package_data': True}
        assert setup_attrs['package_data']

        dist = Distribution(setup_attrs)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        self.assert_package_data_in_manifest(cmd)

    def test_extension_sources_in_sdist(self):
        """
        Ensure that the files listed in Extension.sources and Extension.depends
        are automatically included in the manifest.
        """
        cmd = self.setup_with_extension()
        self.assert_package_data_in_manifest(cmd)
        manifest = cmd.filelist.files
        for path in EXTENSION_SOURCES:
            assert path in manifest

    def test_missing_extension_sources(self):
        """
        Similar to test_extension_sources_in_sdist but the referenced files don't exist.
        Missing files should not be included in distribution (with no error raised).
        """
        for path in EXTENSION_SOURCES:
            os.remove(path)

        cmd = self.setup_with_extension()
        self.assert_package_data_in_manifest(cmd)
        manifest = cmd.filelist.files
        for path in EXTENSION_SOURCES:
            assert path not in manifest

    def test_symlinked_extension_sources(self):
        """
        Similar to test_extension_sources_in_sdist but the referenced files are
        instead symbolic links to project-local files. Referenced file paths
        should be included. Symlink targets themselves should NOT be included.
        """
        symlinked = []
        for path in EXTENSION_SOURCES:
            base, ext = os.path.splitext(path)
            target = base + "_target." + ext

            os.rename(path, target)
            symlink_or_skip_test(os.path.basename(target), path)
            symlinked.append(target)

        cmd = self.setup_with_extension()
        self.assert_package_data_in_manifest(cmd)
        manifest = cmd.filelist.files
        for path in EXTENSION_SOURCES:
            assert path in manifest
        for path in symlinked:
            assert path not in manifest

    _INVALID_PATHS = {
        "must be relative": lambda: (
            os.path.abspath(os.path.join("sdist_test", "f.h"))
        ),
        "can't have `..` segments": lambda: (
            os.path.join("sdist_test", "..", "sdist_test", "f.h")
        ),
        "doesn't exist": lambda: (
            os.path.join("sdist_test", "this_file_does_not_exist.h")
        ),
        "must be inside the project root": lambda: (
            symlink_or_skip_test(
                touch(os.path.join("..", "outside_of_project_root.h")),
                "symlink.h",
            )
        ),
    }

    @skip_under_stdlib_distutils
    @pytest.mark.parametrize("reason", _INVALID_PATHS.keys())
    def test_invalid_extension_depends(self, reason, caplog):
        """
        Due to backwards compatibility reasons, `Extension.depends` should accept
        invalid/weird paths, but then ignore them when building a sdist.

        This test verifies that the source distribution is still built
        successfully with such paths, but that instead of adding these paths to
        the manifest, we emit an informational message, notifying the user that
        the invalid path won't be automatically included.
        """
        invalid_path = self._INVALID_PATHS[reason]()
        extension = Extension(
            name="sdist_test.f",
            sources=[],
            depends=[invalid_path],
        )
        setup_attrs = {**SETUP_ATTRS, 'ext_modules': [extension]}

        dist = Distribution(setup_attrs)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet(), caplog.at_level(logging.INFO):
            cmd.run()

        self.assert_package_data_in_manifest(cmd)
        manifest = cmd.filelist.files
        assert invalid_path not in manifest

        expected_message = [
            message
            for (logger, level, message) in caplog.record_tuples
            if (
                logger == "root"  #
                and level == logging.INFO  #
                and invalid_path in message  #
            )
        ]
        assert len(expected_message) == 1
        (expected_message,) = expected_message
        assert reason in expected_message

    def test_custom_build_py(self):
        """
        Ensure projects defining custom build_py don't break
        when creating sdists (issue #2849)
        """
        from distutils.command.build_py import build_py as OrigBuildPy

        using_custom_command_guard = mock.Mock()

        class CustomBuildPy(OrigBuildPy):
            """
            Some projects have custom commands inheriting from `distutils`
            """

            def get_data_files(self):
                using_custom_command_guard()
                return super().get_data_files()

        setup_attrs = {**SETUP_ATTRS, 'include_package_data': True}
        assert setup_attrs['package_data']

        dist = Distribution(setup_attrs)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Make sure we use the custom command
        cmd.cmdclass = {'build_py': CustomBuildPy}
        cmd.distribution.cmdclass = {'build_py': CustomBuildPy}
        assert cmd.distribution.get_command_class('build_py') == CustomBuildPy

        msg = "setuptools instead of distutils"
        with quiet(), pytest.warns(SetuptoolsDeprecationWarning, match=msg):
            cmd.run()

        using_custom_command_guard.assert_called()
        self.assert_package_data_in_manifest(cmd)

    def test_setup_py_exists(self):
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'foo.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        manifest = cmd.filelist.files
        assert 'setup.py' in manifest

    def test_setup_py_missing(self):
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'foo.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        if os.path.exists("setup.py"):
            os.remove("setup.py")
        with quiet():
            cmd.run()

        manifest = cmd.filelist.files
        assert 'setup.py' not in manifest

    def test_setup_py_excluded(self):
        with open("MANIFEST.in", "w") as manifest_file:
            manifest_file.write("exclude setup.py")

        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'foo.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        manifest = cmd.filelist.files
        assert 'setup.py' not in manifest

    def test_defaults_case_sensitivity(self, source_dir):
        """
        Make sure default files (README.*, etc.) are added in a case-sensitive
        way to avoid problems with packages built on Windows.
        """

        touch(source_dir / 'readme.rst')
        touch(source_dir / 'SETUP.cfg')

        dist = Distribution(SETUP_ATTRS)
        # the extension deliberately capitalized for this test
        # to make sure the actual filename (not capitalized) gets added
        # to the manifest
        dist.script_name = 'setup.PY'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        with quiet():
            cmd.run()

        # lowercase all names so we can test in a
        # case-insensitive way to make sure the files
        # are not included.
        manifest = map(lambda x: x.lower(), cmd.filelist.files)
        assert 'readme.rst' not in manifest, manifest
        assert 'setup.py' not in manifest, manifest
        assert 'setup.cfg' not in manifest, manifest

    @fail_on_ascii
    def test_manifest_is_written_with_utf8_encoding(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        mm = manifest_maker(dist)
        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        os.mkdir('sdist_test.egg-info')

        # UTF-8 filename
        filename = os.path.join('sdist_test', 'smörbröd.py')

        # Must create the file or it will get stripped.
        open(filename, 'w').close()

        # Add UTF-8 filename and write manifest
        with quiet():
            mm.run()
            mm.filelist.append(filename)
            mm.write_manifest()

        contents = read_all_bytes(mm.manifest)

        # The manifest should be UTF-8 encoded
        u_contents = contents.decode('UTF-8')

        # The manifest should contain the UTF-8 filename
        assert posix(filename) in u_contents

    @fail_on_ascii
    def test_write_manifest_allows_utf8_filenames(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        mm = manifest_maker(dist)
        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        os.mkdir('sdist_test.egg-info')

        filename = os.path.join(b'sdist_test', Filenames.utf_8)

        # Must touch the file or risk removal
        open(filename, "w").close()

        # Add filename and write manifest
        with quiet():
            mm.run()
            u_filename = filename.decode('utf-8')
            mm.filelist.files.append(u_filename)
            # Re-write manifest
            mm.write_manifest()

        contents = read_all_bytes(mm.manifest)

        # The manifest should be UTF-8 encoded
        contents.decode('UTF-8')

        # The manifest should contain the UTF-8 filename
        assert posix(filename) in contents

        # The filelist should have been updated as well
        assert u_filename in mm.filelist.files

    @skip_under_xdist
    def test_write_manifest_skips_non_utf8_filenames(self):
        """
        Files that cannot be encoded to UTF-8 (specifically, those that
        weren't originally successfully decoded and have surrogate
        escapes) should be omitted from the manifest.
        See https://bitbucket.org/tarek/distribute/issue/303 for history.
        """
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        mm = manifest_maker(dist)
        mm.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        os.mkdir('sdist_test.egg-info')

        # Latin-1 filename
        filename = os.path.join(b'sdist_test', Filenames.latin_1)

        # Add filename with surrogates and write manifest
        with quiet():
            mm.run()
            u_filename = filename.decode('utf-8', 'surrogateescape')
            mm.filelist.append(u_filename)
            # Re-write manifest
            mm.write_manifest()

        contents = read_all_bytes(mm.manifest)

        # The manifest should be UTF-8 encoded
        contents.decode('UTF-8')

        # The Latin-1 filename should have been skipped
        assert posix(filename) not in contents

        # The filelist should have been updated as well
        assert u_filename not in mm.filelist.files

    @fail_on_ascii
    def test_manifest_is_read_with_utf8_encoding(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Create manifest
        with quiet():
            cmd.run()

        # Add UTF-8 filename to manifest
        filename = os.path.join(b'sdist_test', Filenames.utf_8)
        cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        manifest = open(cmd.manifest, 'ab')
        manifest.write(b'\n' + filename)
        manifest.close()

        # The file must exist to be included in the filelist
        open(filename, 'w').close()

        # Re-read manifest
        cmd.filelist.files = []
        with quiet():
            cmd.read_manifest()

        # The filelist should contain the UTF-8 filename
        filename = filename.decode('utf-8')
        assert filename in cmd.filelist.files

    @fail_on_latin1_encoded_filenames
    def test_read_manifest_skips_non_utf8_filenames(self):
        # Test for #303.
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Create manifest
        with quiet():
            cmd.run()

        # Add Latin-1 filename to manifest
        filename = os.path.join(b'sdist_test', Filenames.latin_1)
        cmd.manifest = os.path.join('sdist_test.egg-info', 'SOURCES.txt')
        manifest = open(cmd.manifest, 'ab')
        manifest.write(b'\n' + filename)
        manifest.close()

        # The file must exist to be included in the filelist
        open(filename, 'w').close()

        # Re-read manifest
        cmd.filelist.files = []
        with quiet():
            cmd.read_manifest()

        # The Latin-1 filename should have been skipped
        filename = filename.decode('latin-1')
        assert filename not in cmd.filelist.files

    @fail_on_ascii
    @fail_on_latin1_encoded_filenames
    def test_sdist_with_utf8_encoded_filename(self):
        # Test for #303.
        dist = Distribution(self.make_strings(SETUP_ATTRS))
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        filename = os.path.join(b'sdist_test', Filenames.utf_8)
        open(filename, 'w').close()

        with quiet():
            cmd.run()

        if sys.platform == 'darwin':
            filename = decompose(filename)

        fs_enc = sys.getfilesystemencoding()

        if sys.platform == 'win32':
            if fs_enc == 'cp1252':
                # Python mangles the UTF-8 filename
                filename = filename.decode('cp1252')
                assert filename in cmd.filelist.files
            else:
                filename = filename.decode('mbcs')
                assert filename in cmd.filelist.files
        else:
            filename = filename.decode('utf-8')
            assert filename in cmd.filelist.files

    @classmethod
    def make_strings(cls, item):
        if isinstance(item, dict):
            return {key: cls.make_strings(value) for key, value in item.items()}
        if isinstance(item, list):
            return list(map(cls.make_strings, item))
        return str(item)

    @fail_on_latin1_encoded_filenames
    @skip_under_xdist
    def test_sdist_with_latin1_encoded_filename(self):
        # Test for #303.
        dist = Distribution(self.make_strings(SETUP_ATTRS))
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()

        # Latin-1 filename
        filename = os.path.join(b'sdist_test', Filenames.latin_1)
        open(filename, 'w').close()
        assert os.path.isfile(filename)

        with quiet():
            cmd.run()

        # not all windows systems have a default FS encoding of cp1252
        if sys.platform == 'win32':
            # Latin-1 is similar to Windows-1252 however
            # on mbcs filesys it is not in latin-1 encoding
            fs_enc = sys.getfilesystemencoding()
            if fs_enc != 'mbcs':
                fs_enc = 'latin-1'
            filename = filename.decode(fs_enc)

            assert filename in cmd.filelist.files
        else:
            # The Latin-1 filename should have been skipped
            filename = filename.decode('latin-1')
            filename not in cmd.filelist.files

    _EXAMPLE_DIRECTIVES = {
        "setup.cfg - long_description and version": """
            [metadata]
            name = testing
            version = file: src/VERSION.txt
            license_files = DOWHATYOUWANT
            long_description = file: README.rst, USAGE.rst
            """,
        "pyproject.toml - static readme/license files and dynamic version": """
            [project]
            name = "testing"
            readme = "USAGE.rst"
            license = {file = "DOWHATYOUWANT"}
            dynamic = ["version"]
            [tool.setuptools.dynamic]
            version = {file = ["src/VERSION.txt"]}
            """,
        "pyproject.toml - directive with str instead of list": """
            [project]
            name = "testing"
            readme = "USAGE.rst"
            license = {file = "DOWHATYOUWANT"}
            dynamic = ["version"]
            [tool.setuptools.dynamic]
            version = {file = "src/VERSION.txt"}
            """,
    }

    @pytest.mark.parametrize("config", _EXAMPLE_DIRECTIVES.keys())
    def test_add_files_referenced_by_config_directives(self, source_dir, config):
        config_file, _, _ = config.partition(" - ")
        config_text = self._EXAMPLE_DIRECTIVES[config]
        (source_dir / 'src').mkdir()
        (source_dir / 'src/VERSION.txt').write_text("0.42", encoding="utf-8")
        (source_dir / 'README.rst').write_text("hello world!", encoding="utf-8")
        (source_dir / 'USAGE.rst').write_text("hello world!", encoding="utf-8")
        (source_dir / 'DOWHATYOUWANT').write_text("hello world!", encoding="utf-8")
        (source_dir / config_file).write_text(config_text, encoding="utf-8")

        dist = Distribution({"packages": []})
        dist.script_name = 'setup.py'
        dist.parse_config_files()

        cmd = sdist(dist)
        cmd.ensure_finalized()
        with quiet():
            cmd.run()

        assert (
            'src/VERSION.txt' in cmd.filelist.files
            or 'src\\VERSION.txt' in cmd.filelist.files
        )
        assert 'USAGE.rst' in cmd.filelist.files
        assert 'DOWHATYOUWANT' in cmd.filelist.files
        assert '/' not in cmd.filelist.files
        assert '\\' not in cmd.filelist.files

    def test_pyproject_toml_in_sdist(self, source_dir):
        """
        Check if pyproject.toml is included in source distribution if present
        """
        touch(source_dir / 'pyproject.toml')
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()
        with quiet():
            cmd.run()
        manifest = cmd.filelist.files
        assert 'pyproject.toml' in manifest

    def test_pyproject_toml_excluded(self, source_dir):
        """
        Check that pyproject.toml can excluded even if present
        """
        touch(source_dir / 'pyproject.toml')
        with open('MANIFEST.in', 'w') as mts:
            print('exclude pyproject.toml', file=mts)
        dist = Distribution(SETUP_ATTRS)
        dist.script_name = 'setup.py'
        cmd = sdist(dist)
        cmd.ensure_finalized()
        with quiet():
            cmd.run()
        manifest = cmd.filelist.files
        assert 'pyproject.toml' not in manifest

    def test_build_subcommand_source_files(self, source_dir):
        touch(source_dir / '.myfile~')

        # Sanity check: without custom commands file list should not be affected
        dist = Distribution({**SETUP_ATTRS, "script_name": "setup.py"})
        cmd = sdist(dist)
        cmd.ensure_finalized()
        with quiet():
            cmd.run()
        manifest = cmd.filelist.files
        assert '.myfile~' not in manifest

        # Test: custom command should be able to augment file list
        dist = Distribution({**SETUP_ATTRS, "script_name": "setup.py"})
        build = dist.get_command_obj("build")
        build.sub_commands = [*build.sub_commands, ("build_custom", None)]

        class build_custom(Command):
            def initialize_options(self):
                ...

            def finalize_options(self):
                ...

            def run(self):
                ...

            def get_source_files(self):
                return ['.myfile~']

        dist.cmdclass.update(build_custom=build_custom)

        cmd = sdist(dist)
        cmd.use_defaults = True
        cmd.ensure_finalized()
        with quiet():
            cmd.run()
        manifest = cmd.filelist.files
        assert '.myfile~' in manifest


def test_default_revctrl():
    """
    When _default_revctrl was removed from the `setuptools.command.sdist`
    module in 10.0, it broke some systems which keep an old install of
    setuptools (Distribute) around. Those old versions require that the
    setuptools package continue to implement that interface, so this
    function provides that interface, stubbed. See #320 for details.

    This interface must be maintained until Ubuntu 12.04 is no longer
    supported (by Setuptools).
    """
    (ep,) = metadata.EntryPoints._from_text(
        """
        [setuptools.file_finders]
        svn_cvs = setuptools.command.sdist:_default_revctrl
        """
    )
    res = ep.load()
    assert hasattr(res, '__iter__')


class TestRegressions:
    """
    Can be removed/changed if the project decides to change how it handles symlinks
    or external files.
    """

    @staticmethod
    def files_for_symlink_in_extension_depends(tmp_path, dep_path):
        return {
            "external": {
                "dir": {"file.h": ""},
            },
            "project": {
                "setup.py": cleandoc(
                    f"""
                    from setuptools import Extension, setup
                    setup(
                        name="myproj",
                        version="42",
                        ext_modules=[
                            Extension(
                                "hello", sources=["hello.pyx"],
                                depends=[{dep_path!r}]
                            )
                        ],
                    )
                    """
                ),
                "hello.pyx": "",
                "MANIFEST.in": "global-include *.h",
            },
        }

    @pytest.mark.parametrize(
        "dep_path", ("myheaders/dir/file.h", "myheaders/dir/../dir/file.h")
    )
    def test_symlink_in_extension_depends(self, monkeypatch, tmp_path, dep_path):
        # Given a project with a symlinked dir and a "depends" targeting that dir
        files = self.files_for_symlink_in_extension_depends(tmp_path, dep_path)
        jaraco.path.build(files, prefix=str(tmp_path))
        symlink_or_skip_test(tmp_path / "external", tmp_path / "project/myheaders")

        # When `sdist` runs, there should be no error
        members = run_sdist(monkeypatch, tmp_path / "project")
        # and the sdist should contain the symlinked files
        for expected in (
            "myproj-42/hello.pyx",
            "myproj-42/myheaders/dir/file.h",
        ):
            assert expected in members

    @staticmethod
    def files_for_external_path_in_extension_depends(tmp_path, dep_path):
        head, _, tail = dep_path.partition("$tmp_path$/")
        dep_path = tmp_path / tail if tail else head

        return {
            "external": {
                "dir": {"file.h": ""},
            },
            "project": {
                "setup.py": cleandoc(
                    f"""
                    from setuptools import Extension, setup
                    setup(
                        name="myproj",
                        version="42",
                        ext_modules=[
                            Extension(
                                "hello", sources=["hello.pyx"],
                                depends=[{str(dep_path)!r}]
                            )
                        ],
                    )
                    """
                ),
                "hello.pyx": "",
                "MANIFEST.in": "global-include *.h",
            },
        }

    @pytest.mark.parametrize(
        "dep_path", ("$tmp_path$/external/dir/file.h", "../external/dir/file.h")
    )
    def test_external_path_in_extension_depends(self, monkeypatch, tmp_path, dep_path):
        # Given a project with a "depends" targeting an external dir
        files = self.files_for_external_path_in_extension_depends(tmp_path, dep_path)
        jaraco.path.build(files, prefix=str(tmp_path))
        # When `sdist` runs, there should be no error
        members = run_sdist(monkeypatch, tmp_path / "project")
        # and the sdist should not contain the external file
        for name in members:
            assert "file.h" not in name


def run_sdist(monkeypatch, project):
    """Given a project directory, run the sdist and return its contents"""
    monkeypatch.chdir(project)
    with quiet():
        run_setup("setup.py", ["sdist"])

    archive = next((project / "dist").glob("*.tar.gz"))
    with tarfile.open(str(archive)) as tar:
        return set(tar.getnames())
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_setopt.py0000644000175100001730000000254514467657412021772 0ustar00runnerdockerimport io
import configparser

from setuptools.command import setopt


class TestEdit:
    @staticmethod
    def parse_config(filename):
        parser = configparser.ConfigParser()
        with io.open(filename, encoding='utf-8') as reader:
            parser.read_file(reader)
        return parser

    @staticmethod
    def write_text(file, content):
        with io.open(file, 'wb') as strm:
            strm.write(content.encode('utf-8'))

    def test_utf8_encoding_retained(self, tmpdir):
        """
        When editing a file, non-ASCII characters encoded in
        UTF-8 should be retained.
        """
        config = tmpdir.join('setup.cfg')
        self.write_text(str(config), '[names]\njaraco=джарако')
        setopt.edit_config(str(config), dict(names=dict(other='yes')))
        parser = self.parse_config(str(config))
        assert parser.get('names', 'jaraco') == 'джарако'
        assert parser.get('names', 'other') == 'yes'

    def test_case_retained(self, tmpdir):
        """
        When editing a file, case of keys should be retained.
        """
        config = tmpdir.join('setup.cfg')
        self.write_text(str(config), '[names]\nFoO=bAr')
        setopt.edit_config(str(config), dict(names=dict(oTher='yes')))
        actual = config.read_text(encoding='ascii')
        assert 'FoO' in actual
        assert 'oTher' in actual
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_setuptools.py0000644000175100001730000002313314467657412022671 0ustar00runnerdocker"""Tests for the 'setuptools' package"""

import sys
import os
import distutils.core
import distutils.cmd
from distutils.errors import DistutilsOptionError
from distutils.errors import DistutilsSetupError
from distutils.core import Extension
from zipfile import ZipFile

import pytest

from setuptools.extern.packaging import version

import setuptools
import setuptools.dist
import setuptools.depends as dep
from setuptools.depends import Require


@pytest.fixture(autouse=True)
def isolated_dir(tmpdir_cwd):
    yield


def makeSetup(**args):
    """Return distribution from 'setup(**args)', without executing commands"""

    distutils.core._setup_stop_after = "commandline"

    # Don't let system command line leak into tests!
    args.setdefault('script_args', ['install'])

    try:
        return setuptools.setup(**args)
    finally:
        distutils.core._setup_stop_after = None


needs_bytecode = pytest.mark.skipif(
    not hasattr(dep, 'get_module_constant'),
    reason="bytecode support not available",
)


class TestDepends:
    def testExtractConst(self):
        if not hasattr(dep, 'extract_constant'):
            # skip on non-bytecode platforms
            return

        def f1():
            global x, y, z
            x = "test"
            y = z

        fc = f1.__code__

        # unrecognized name
        assert dep.extract_constant(fc, 'q', -1) is None

        # constant assigned
        dep.extract_constant(fc, 'x', -1) == "test"

        # expression assigned
        dep.extract_constant(fc, 'y', -1) == -1

        # recognized name, not assigned
        dep.extract_constant(fc, 'z', -1) is None

    def testFindModule(self):
        with pytest.raises(ImportError):
            dep.find_module('no-such.-thing')
        with pytest.raises(ImportError):
            dep.find_module('setuptools.non-existent')
        f, p, i = dep.find_module('setuptools.tests')
        f.close()

    @needs_bytecode
    def testModuleExtract(self):
        from json import __version__

        assert dep.get_module_constant('json', '__version__') == __version__
        assert dep.get_module_constant('sys', 'version') == sys.version
        assert (
            dep.get_module_constant('setuptools.tests.test_setuptools', '__doc__')
            == __doc__
        )

    @needs_bytecode
    def testRequire(self):
        req = Require('Json', '1.0.3', 'json')

        assert req.name == 'Json'
        assert req.module == 'json'
        assert req.requested_version == version.Version('1.0.3')
        assert req.attribute == '__version__'
        assert req.full_name() == 'Json-1.0.3'

        from json import __version__

        assert str(req.get_version()) == __version__
        assert req.version_ok('1.0.9')
        assert not req.version_ok('0.9.1')
        assert not req.version_ok('unknown')

        assert req.is_present()
        assert req.is_current()

        req = Require('Do-what-I-mean', '1.0', 'd-w-i-m')
        assert not req.is_present()
        assert not req.is_current()

    @needs_bytecode
    def test_require_present(self):
        # In #1896, this test was failing for months with the only
        # complaint coming from test runners (not end users).
        # TODO: Evaluate if this code is needed at all.
        req = Require('Tests', None, 'tests', homepage="http://example.com")
        assert req.format is None
        assert req.attribute is None
        assert req.requested_version is None
        assert req.full_name() == 'Tests'
        assert req.homepage == 'http://example.com'

        from setuptools.tests import __path__

        paths = [os.path.dirname(p) for p in __path__]
        assert req.is_present(paths)
        assert req.is_current(paths)


class TestDistro:
    def setup_method(self, method):
        self.e1 = Extension('bar.ext', ['bar.c'])
        self.e2 = Extension('c.y', ['y.c'])

        self.dist = makeSetup(
            packages=['a', 'a.b', 'a.b.c', 'b', 'c'],
            py_modules=['b.d', 'x'],
            ext_modules=(self.e1, self.e2),
            package_dir={},
        )

    def testDistroType(self):
        assert isinstance(self.dist, setuptools.dist.Distribution)

    def testExcludePackage(self):
        self.dist.exclude_package('a')
        assert self.dist.packages == ['b', 'c']

        self.dist.exclude_package('b')
        assert self.dist.packages == ['c']
        assert self.dist.py_modules == ['x']
        assert self.dist.ext_modules == [self.e1, self.e2]

        self.dist.exclude_package('c')
        assert self.dist.packages == []
        assert self.dist.py_modules == ['x']
        assert self.dist.ext_modules == [self.e1]

        # test removals from unspecified options
        makeSetup().exclude_package('x')

    def testIncludeExclude(self):
        # remove an extension
        self.dist.exclude(ext_modules=[self.e1])
        assert self.dist.ext_modules == [self.e2]

        # add it back in
        self.dist.include(ext_modules=[self.e1])
        assert self.dist.ext_modules == [self.e2, self.e1]

        # should not add duplicate
        self.dist.include(ext_modules=[self.e1])
        assert self.dist.ext_modules == [self.e2, self.e1]

    def testExcludePackages(self):
        self.dist.exclude(packages=['c', 'b', 'a'])
        assert self.dist.packages == []
        assert self.dist.py_modules == ['x']
        assert self.dist.ext_modules == [self.e1]

    def testEmpty(self):
        dist = makeSetup()
        dist.include(packages=['a'], py_modules=['b'], ext_modules=[self.e2])
        dist = makeSetup()
        dist.exclude(packages=['a'], py_modules=['b'], ext_modules=[self.e2])

    def testContents(self):
        assert self.dist.has_contents_for('a')
        self.dist.exclude_package('a')
        assert not self.dist.has_contents_for('a')

        assert self.dist.has_contents_for('b')
        self.dist.exclude_package('b')
        assert not self.dist.has_contents_for('b')

        assert self.dist.has_contents_for('c')
        self.dist.exclude_package('c')
        assert not self.dist.has_contents_for('c')

    def testInvalidIncludeExclude(self):
        with pytest.raises(DistutilsSetupError):
            self.dist.include(nonexistent_option='x')
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(nonexistent_option='x')
        with pytest.raises(DistutilsSetupError):
            self.dist.include(packages={'x': 'y'})
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(packages={'x': 'y'})
        with pytest.raises(DistutilsSetupError):
            self.dist.include(ext_modules={'x': 'y'})
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(ext_modules={'x': 'y'})

        with pytest.raises(DistutilsSetupError):
            self.dist.include(package_dir=['q'])
        with pytest.raises(DistutilsSetupError):
            self.dist.exclude(package_dir=['q'])


class TestCommandTests:
    def testTestIsCommand(self):
        test_cmd = makeSetup().get_command_obj('test')
        assert isinstance(test_cmd, distutils.cmd.Command)

    def testLongOptSuiteWNoDefault(self):
        ts1 = makeSetup(script_args=['test', '--test-suite=foo.tests.suite'])
        ts1 = ts1.get_command_obj('test')
        ts1.ensure_finalized()
        assert ts1.test_suite == 'foo.tests.suite'

    def testDefaultSuite(self):
        ts2 = makeSetup(test_suite='bar.tests.suite').get_command_obj('test')
        ts2.ensure_finalized()
        assert ts2.test_suite == 'bar.tests.suite'

    def testDefaultWModuleOnCmdLine(self):
        ts3 = makeSetup(
            test_suite='bar.tests', script_args=['test', '-m', 'foo.tests']
        ).get_command_obj('test')
        ts3.ensure_finalized()
        assert ts3.test_module == 'foo.tests'
        assert ts3.test_suite == 'foo.tests.test_suite'

    def testConflictingOptions(self):
        ts4 = makeSetup(
            script_args=['test', '-m', 'bar.tests', '-s', 'foo.tests.suite']
        ).get_command_obj('test')
        with pytest.raises(DistutilsOptionError):
            ts4.ensure_finalized()

    def testNoSuite(self):
        ts5 = makeSetup().get_command_obj('test')
        ts5.ensure_finalized()
        assert ts5.test_suite is None


@pytest.fixture
def example_source(tmpdir):
    tmpdir.mkdir('foo')
    (tmpdir / 'foo/bar.py').write('')
    (tmpdir / 'readme.txt').write('')
    return tmpdir


def test_findall(example_source):
    found = list(setuptools.findall(str(example_source)))
    expected = ['readme.txt', 'foo/bar.py']
    expected = [example_source.join(fn) for fn in expected]
    assert found == expected


def test_findall_curdir(example_source):
    with example_source.as_cwd():
        found = list(setuptools.findall())
    expected = ['readme.txt', os.path.join('foo', 'bar.py')]
    assert found == expected


@pytest.fixture
def can_symlink(tmpdir):
    """
    Skip if cannot create a symbolic link
    """
    link_fn = 'link'
    target_fn = 'target'
    try:
        os.symlink(target_fn, link_fn)
    except (OSError, NotImplementedError, AttributeError):
        pytest.skip("Cannot create symbolic links")
    os.remove(link_fn)


def test_findall_missing_symlink(tmpdir, can_symlink):
    with tmpdir.as_cwd():
        os.symlink('foo', 'bar')
        found = list(setuptools.findall())
        assert found == []


def test_its_own_wheel_does_not_contain_tests(setuptools_wheel):
    with ZipFile(setuptools_wheel) as zipfile:
        contents = [f.replace(os.sep, '/') for f in zipfile.namelist()]

    for member in contents:
        assert '/tests/' not in member


def test_convert_path_deprecated():
    with pytest.warns(setuptools.SetuptoolsDeprecationWarning):
        setuptools.convert_path('setuptools/tests')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_test.py0000644000175100001730000000175614467657412021436 0ustar00runnerdockerimport pytest
from jaraco import path

from setuptools.command.test import test
from setuptools.dist import Distribution

from .textwrap import DALS


@pytest.mark.usefixtures('tmpdir_cwd')
def test_tests_are_run_once(capfd):
    params = dict(
        packages=['dummy'],
    )
    files = {
        'setup.py': 'from setuptools import setup; setup('
        + ','.join(f'{name}={params[name]!r}' for name in params)
        + ')',
        'dummy': {
            '__init__.py': '',
            'test_dummy.py': DALS(
                """
                import unittest
                class TestTest(unittest.TestCase):
                    def test_test(self):
                        print('Foo')
                """
            ),
        },
    }
    path.build(files)
    dist = Distribution(params)
    dist.script_name = 'setup.py'
    cmd = test(dist)
    cmd.ensure_finalized()
    cmd.run()
    out, err = capfd.readouterr()
    assert out.endswith('Foo\n')
    assert len(out.split('Foo')) == 2
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_unicode_utils.py0000644000175100001730000000047414467657412023321 0ustar00runnerdockerfrom setuptools import unicode_utils


def test_filesys_decode_fs_encoding_is_None(monkeypatch):
    """
    Test filesys_decode does not raise TypeError when
    getfilesystemencoding returns None.
    """
    monkeypatch.setattr('sys.getfilesystemencoding', lambda: None)
    unicode_utils.filesys_decode(b'test')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_upload.py0000644000175100001730000000077314467657412021741 0ustar00runnerdockerfrom setuptools.command.upload import upload
from setuptools.dist import Distribution
from setuptools.errors import RemovedCommandError

from unittest import mock

import pytest


class TestUpload:
    def test_upload_exception(self):
        """Ensure that the register command has been properly removed."""
        dist = Distribution()
        dist.dist_files = [(mock.Mock(), mock.Mock(), mock.Mock())]

        cmd = upload(dist)

        with pytest.raises(RemovedCommandError):
            cmd.run()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_virtualenv.py0000644000175100001730000001407014467657412022647 0ustar00runnerdockerimport os
import sys
import subprocess
from urllib.request import urlopen
from urllib.error import URLError

import pathlib

import pytest

from . import contexts
from .textwrap import DALS
from .test_easy_install import make_nspkg_sdist


@pytest.fixture(autouse=True)
def pytest_virtualenv_works(venv):
    """
    pytest_virtualenv may not work. if it doesn't, skip these
    tests. See #1284.
    """
    venv_prefix = venv.run(["python", "-c", "import sys; print(sys.prefix)"]).strip()
    if venv_prefix == sys.prefix:
        pytest.skip("virtualenv is broken (see pypa/setuptools#1284)")


def test_clean_env_install(venv_without_setuptools, setuptools_wheel):
    """
    Check setuptools can be installed in a clean environment.
    """
    cmd = ["python", "-m", "pip", "install", str(setuptools_wheel)]
    venv_without_setuptools.run(cmd)


def access_pypi():
    # Detect if tests are being run without connectivity
    if not os.environ.get('NETWORK_REQUIRED', False):  # pragma: nocover
        try:
            urlopen('https://pypi.org', timeout=1)
        except URLError:
            # No network, disable most of these tests
            return False

    return True


@pytest.mark.skipif(
    'platform.python_implementation() == "PyPy"',
    reason="https://github.com/pypa/setuptools/pull/2865#issuecomment-965834995",
)
@pytest.mark.skipif(not access_pypi(), reason="no network")
# ^-- Even when it is not necessary to install a different version of `pip`
#     the build process will still try to download `wheel`, see #3147 and #2986.
@pytest.mark.parametrize(
    'pip_version',
    [
        None,
        pytest.param(
            'pip<20.1',
            marks=pytest.mark.xfail(
                'sys.version_info >= (3, 12)',
                reason="pip 23.1.2 required for Python 3.12 and later",
            ),
        ),
        pytest.param(
            'pip<21',
            marks=pytest.mark.xfail(
                'sys.version_info >= (3, 12)',
                reason="pip 23.1.2 required for Python 3.12 and later",
            ),
        ),
        pytest.param(
            'pip<22',
            marks=pytest.mark.xfail(
                'sys.version_info >= (3, 12)',
                reason="pip 23.1.2 required for Python 3.12 and later",
            ),
        ),
        pytest.param(
            'pip<23',
            marks=pytest.mark.xfail(
                'sys.version_info >= (3, 12)',
                reason="pip 23.1.2 required for Python 3.12 and later",
            ),
        ),
        pytest.param(
            'https://github.com/pypa/pip/archive/main.zip',
            marks=pytest.mark.xfail(reason='#2975'),
        ),
    ],
)
def test_pip_upgrade_from_source(
    pip_version, venv_without_setuptools, setuptools_wheel, setuptools_sdist
):
    """
    Check pip can upgrade setuptools from source.
    """
    # Install pip/wheel, in a venv without setuptools (as it
    # should not be needed for bootstrapping from source)
    venv = venv_without_setuptools
    venv.run(["pip", "install", "-U", "wheel"])
    if pip_version is not None:
        venv.run(["python", "-m", "pip", "install", "-U", pip_version, "--retries=1"])
    with pytest.raises(subprocess.CalledProcessError):
        # Meta-test to make sure setuptools is not installed
        venv.run(["python", "-c", "import setuptools"])

    # Then install from wheel.
    venv.run(["pip", "install", str(setuptools_wheel)])
    # And finally try to upgrade from source.
    venv.run(["pip", "install", "--no-cache-dir", "--upgrade", str(setuptools_sdist)])


def _check_test_command_install_requirements(venv, tmpdir):
    """
    Check the test command will install all required dependencies.
    """

    def sdist(distname, version):
        dist_path = tmpdir.join('%s-%s.tar.gz' % (distname, version))
        make_nspkg_sdist(str(dist_path), distname, version)
        return dist_path

    dependency_links = [
        pathlib.Path(str(dist_path)).as_uri()
        for dist_path in (
            sdist('foobar', '2.4'),
            sdist('bits', '4.2'),
            sdist('bobs', '6.0'),
            sdist('pieces', '0.6'),
        )
    ]
    with tmpdir.join('setup.py').open('w') as fp:
        fp.write(
            DALS(
                '''
            from setuptools import setup

            setup(
                dependency_links={dependency_links!r},
                install_requires=[
                    'barbazquux1; sys_platform in ""',
                    'foobar==2.4',
                ],
                setup_requires='bits==4.2',
                tests_require="""
                    bobs==6.0
                """,
                extras_require={{
                    'test': ['barbazquux2'],
                    ':"" in sys_platform': 'pieces==0.6',
                    ':python_version > "1"': """
                        pieces
                        foobar
                    """,
                }}
            )
            '''.format(
                    dependency_links=dependency_links
                )
            )
        )
    with tmpdir.join('test.py').open('w') as fp:
        fp.write(
            DALS(
                '''
            import foobar
            import bits
            import bobs
            import pieces

            open('success', 'w').close()
            '''
            )
        )

    cmd = ["python", 'setup.py', 'test', '-s', 'test']
    venv.run(cmd, cwd=str(tmpdir))
    assert tmpdir.join('success').check()


def test_test_command_install_requirements(venv, tmpdir, tmpdir_cwd):
    # Ensure pip is installed.
    venv.run(["python", "-c", "import pip"])
    # disable index URL so bits and bobs aren't requested from PyPI
    with contexts.environment(PYTHONPATH=None, PIP_NO_INDEX="1"):
        _check_test_command_install_requirements(venv, tmpdir)


def test_no_missing_dependencies(bare_venv, request):
    """
    Quick and dirty test to ensure all external dependencies are vendored.
    """
    setuptools_dir = request.config.rootdir
    for command in ('upload',):  # sorted(distutils.command.__all__):
        bare_venv.run(['python', 'setup.py', command, '-h'], cwd=setuptools_dir)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_warnings.py0000644000175100001730000000646514467657412022311 0ustar00runnerdockerfrom inspect import cleandoc

import pytest

from setuptools.warnings import SetuptoolsDeprecationWarning, SetuptoolsWarning


_EXAMPLES = {
    "default": dict(
        args=("Hello {x}", "\n\t{target} {v:.1f}"),
        kwargs={"x": 5, "v": 3, "target": "World"},
        expected="""
    Hello 5
    !!

            ********************************************************************************
            World 3.0
            ********************************************************************************

    !!
    """,  # noqa,
    ),
    "futue_due_date": dict(
        args=("Summary", "Lorem ipsum"),
        kwargs={"due_date": (9999, 11, 22)},
        expected="""
    Summary
    !!

            ********************************************************************************
            Lorem ipsum

            By 9999-Nov-22, you need to update your project and remove deprecated calls
            or your builds will no longer be supported.
            ********************************************************************************

    !!
    """,  # noqa
    ),
    "past_due_date_with_docs": dict(
        args=("Summary", "Lorem ipsum"),
        kwargs={"due_date": (2000, 11, 22), "see_docs": "some_page.html"},
        expected="""
    Summary
    !!

            ********************************************************************************
            Lorem ipsum

            This deprecation is overdue, please update your project and remove deprecated
            calls to avoid build errors in the future.

            See https://setuptools.pypa.io/en/latest/some_page.html for details.
            ********************************************************************************

    !!
    """,  # noqa
    ),
}


@pytest.mark.parametrize("example_name", _EXAMPLES.keys())
def test_formatting(monkeypatch, example_name):
    """
    It should automatically handle indentation, interpolation and things like due date.
    """
    args = _EXAMPLES[example_name]["args"]
    kwargs = _EXAMPLES[example_name]["kwargs"]
    expected = _EXAMPLES[example_name]["expected"]

    monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "false")
    with pytest.warns(SetuptoolsWarning) as warn_info:
        SetuptoolsWarning.emit(*args, **kwargs)
    assert _get_message(warn_info) == cleandoc(expected)


def test_due_date_enforcement(monkeypatch):
    class _MyDeprecation(SetuptoolsDeprecationWarning):
        _SUMMARY = "Summary"
        _DETAILS = "Lorem ipsum"
        _DUE_DATE = (2000, 11, 22)
        _SEE_DOCS = "some_page.html"

    monkeypatch.setenv("SETUPTOOLS_ENFORCE_DEPRECATION", "true")
    with pytest.raises(SetuptoolsDeprecationWarning) as exc_info:
        _MyDeprecation.emit()

    expected = """
    Summary
    !!

            ********************************************************************************
            Lorem ipsum

            This deprecation is overdue, please update your project and remove deprecated
            calls to avoid build errors in the future.

            See https://setuptools.pypa.io/en/latest/some_page.html for details.
            ********************************************************************************

    !!
    """  # noqa
    assert str(exc_info.value) == cleandoc(expected)


def _get_message(warn_info):
    return next(warn.message.args[0] for warn in warn_info)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_wheel.py0000644000175100001730000004636114467657412021564 0ustar00runnerdocker"""wheel tests
"""

from distutils.sysconfig import get_config_var
from distutils.util import get_platform
import contextlib
import pathlib
import stat
import glob
import inspect
import os
import shutil
import subprocess
import sys
import zipfile

import pytest
from jaraco import path

from pkg_resources import Distribution, PathMetadata, PY_MAJOR
from setuptools.extern.packaging.utils import canonicalize_name
from setuptools.extern.packaging.tags import parse_tag
from setuptools.wheel import Wheel

from .contexts import tempdir
from .textwrap import DALS


WHEEL_INFO_TESTS = (
    ('invalid.whl', ValueError),
    (
        'simplewheel-2.0-1-py2.py3-none-any.whl',
        {
            'project_name': 'simplewheel',
            'version': '2.0',
            'build': '1',
            'py_version': 'py2.py3',
            'abi': 'none',
            'platform': 'any',
        },
    ),
    (
        'simple.dist-0.1-py2.py3-none-any.whl',
        {
            'project_name': 'simple.dist',
            'version': '0.1',
            'build': None,
            'py_version': 'py2.py3',
            'abi': 'none',
            'platform': 'any',
        },
    ),
    (
        'example_pkg_a-1-py3-none-any.whl',
        {
            'project_name': 'example_pkg_a',
            'version': '1',
            'build': None,
            'py_version': 'py3',
            'abi': 'none',
            'platform': 'any',
        },
    ),
    (
        'PyQt5-5.9-5.9.1-cp35.cp36.cp37-abi3-manylinux1_x86_64.whl',
        {
            'project_name': 'PyQt5',
            'version': '5.9',
            'build': '5.9.1',
            'py_version': 'cp35.cp36.cp37',
            'abi': 'abi3',
            'platform': 'manylinux1_x86_64',
        },
    ),
)


@pytest.mark.parametrize(
    ('filename', 'info'), WHEEL_INFO_TESTS, ids=[t[0] for t in WHEEL_INFO_TESTS]
)
def test_wheel_info(filename, info):
    if inspect.isclass(info):
        with pytest.raises(info):
            Wheel(filename)
        return
    w = Wheel(filename)
    assert {k: getattr(w, k) for k in info.keys()} == info


@contextlib.contextmanager
def build_wheel(extra_file_defs=None, **kwargs):
    file_defs = {
        'setup.py': (
            DALS(
                '''
            # -*- coding: utf-8 -*-
            from setuptools import setup
            import setuptools
            setup(**%r)
            '''
            )
            % kwargs
        ).encode('utf-8'),
    }
    if extra_file_defs:
        file_defs.update(extra_file_defs)
    with tempdir() as source_dir:
        path.build(file_defs, source_dir)
        subprocess.check_call(
            (sys.executable, 'setup.py', '-q', 'bdist_wheel'), cwd=source_dir
        )
        yield glob.glob(os.path.join(source_dir, 'dist', '*.whl'))[0]


def tree_set(root):
    contents = set()
    for dirpath, dirnames, filenames in os.walk(root):
        for filename in filenames:
            contents.add(os.path.join(os.path.relpath(dirpath, root), filename))
    return contents


def flatten_tree(tree):
    """Flatten nested dicts and lists into a full list of paths"""
    output = set()
    for node, contents in tree.items():
        if isinstance(contents, dict):
            contents = flatten_tree(contents)

        for elem in contents:
            if isinstance(elem, dict):
                output |= {os.path.join(node, val) for val in flatten_tree(elem)}
            else:
                output.add(os.path.join(node, elem))
    return output


def format_install_tree(tree):
    return {
        x.format(
            py_version=PY_MAJOR,
            platform=get_platform(),
            shlib_ext=get_config_var('EXT_SUFFIX') or get_config_var('SO'),
        )
        for x in tree
    }


def _check_wheel_install(
    filename, install_dir, install_tree_includes, project_name, version, requires_txt
):
    w = Wheel(filename)
    egg_path = os.path.join(install_dir, w.egg_name())
    w.install_as_egg(egg_path)
    if install_tree_includes is not None:
        install_tree = format_install_tree(install_tree_includes)
        exp = tree_set(install_dir)
        assert install_tree.issubset(exp), install_tree - exp

    metadata = PathMetadata(egg_path, os.path.join(egg_path, 'EGG-INFO'))
    dist = Distribution.from_filename(egg_path, metadata=metadata)
    assert dist.project_name == project_name
    assert dist.version == version
    if requires_txt is None:
        assert not dist.has_metadata('requires.txt')
    else:
        # Order must match to ensure reproducibility.
        assert requires_txt == dist.get_metadata('requires.txt').lstrip()


class Record:
    def __init__(self, id, **kwargs):
        self._id = id
        self._fields = kwargs

    def __repr__(self):
        return '%s(**%r)' % (self._id, self._fields)


WHEEL_INSTALL_TESTS = (
    dict(
        id='basic',
        file_defs={'foo': {'__init__.py': ''}},
        setup_kwargs=dict(
            packages=['foo'],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': {
                    'EGG-INFO': ['PKG-INFO', 'RECORD', 'WHEEL', 'top_level.txt'],
                    'foo': ['__init__.py'],
                }
            }
        ),
    ),
    dict(
        id='utf-8',
        setup_kwargs=dict(
            description='Description accentuée',
        ),
    ),
    dict(
        id='data',
        file_defs={
            'data.txt': DALS(
                '''
                Some data...
                '''
            ),
        },
        setup_kwargs=dict(
            data_files=[('data_dir', ['data.txt'])],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': {
                    'EGG-INFO': ['PKG-INFO', 'RECORD', 'WHEEL', 'top_level.txt'],
                    'data_dir': ['data.txt'],
                }
            }
        ),
    ),
    dict(
        id='extension',
        file_defs={
            'extension.c': DALS(
                '''
                #include "Python.h"

                #if PY_MAJOR_VERSION >= 3

                static struct PyModuleDef moduledef = {
                        PyModuleDef_HEAD_INIT,
                        "extension",
                        NULL,
                        0,
                        NULL,
                        NULL,
                        NULL,
                        NULL,
                        NULL
                };

                #define INITERROR return NULL

                PyMODINIT_FUNC PyInit_extension(void)

                #else

                #define INITERROR return

                void initextension(void)

                #endif
                {
                #if PY_MAJOR_VERSION >= 3
                    PyObject *module = PyModule_Create(&moduledef);
                #else
                    PyObject *module = Py_InitModule("extension", NULL);
                #endif
                    if (module == NULL)
                        INITERROR;
                #if PY_MAJOR_VERSION >= 3
                    return module;
                #endif
                }
                '''
            ),
        },
        setup_kwargs=dict(
            ext_modules=[
                Record(
                    'setuptools.Extension', name='extension', sources=['extension.c']
                )
            ],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}-{platform}.egg': [
                    'extension{shlib_ext}',
                    {
                        'EGG-INFO': [
                            'PKG-INFO',
                            'RECORD',
                            'WHEEL',
                            'top_level.txt',
                        ]
                    },
                ]
            }
        ),
    ),
    dict(
        id='header',
        file_defs={
            'header.h': DALS(
                '''
                '''
            ),
        },
        setup_kwargs=dict(
            headers=['header.h'],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': [
                    'header.h',
                    {
                        'EGG-INFO': [
                            'PKG-INFO',
                            'RECORD',
                            'WHEEL',
                            'top_level.txt',
                        ]
                    },
                ]
            }
        ),
    ),
    dict(
        id='script',
        file_defs={
            'script.py': DALS(
                '''
                #/usr/bin/python
                print('hello world!')
                '''
            ),
            'script.sh': DALS(
                '''
                #/bin/sh
                echo 'hello world!'
                '''
            ),
        },
        setup_kwargs=dict(
            scripts=['script.py', 'script.sh'],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': {
                    'EGG-INFO': [
                        'PKG-INFO',
                        'RECORD',
                        'WHEEL',
                        'top_level.txt',
                        {'scripts': ['script.py', 'script.sh']},
                    ]
                }
            }
        ),
    ),
    dict(
        id='requires1',
        install_requires='foobar==2.0',
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': {
                    'EGG-INFO': [
                        'PKG-INFO',
                        'RECORD',
                        'WHEEL',
                        'requires.txt',
                        'top_level.txt',
                    ]
                }
            }
        ),
        requires_txt=DALS(
            '''
            foobar==2.0
            '''
        ),
    ),
    dict(
        id='requires2',
        install_requires='''
        bar
        foo<=2.0; %r in sys_platform
        '''
        % sys.platform,
        requires_txt=DALS(
            '''
            bar
            foo<=2.0
            '''
        ),
    ),
    dict(
        id='requires3',
        install_requires='''
        bar; %r != sys_platform
        '''
        % sys.platform,
    ),
    dict(
        id='requires4',
        install_requires='''
        foo
        ''',
        extras_require={
            'extra': 'foobar>3',
        },
        requires_txt=DALS(
            '''
            foo

            [extra]
            foobar>3
            '''
        ),
    ),
    dict(
        id='requires5',
        extras_require={
            'extra': 'foobar; %r != sys_platform' % sys.platform,
        },
        requires_txt=DALS(
            '''
            [extra]
            '''
        ),
    ),
    dict(
        id='requires_ensure_order',
        install_requires='''
        foo
        bar
        baz
        qux
        ''',
        extras_require={
            'extra': '''
            foobar>3
            barbaz>4
            bazqux>5
            quxzap>6
            ''',
        },
        requires_txt=DALS(
            '''
            foo
            bar
            baz
            qux

            [extra]
            foobar>3
            barbaz>4
            bazqux>5
            quxzap>6
            '''
        ),
    ),
    dict(
        id='namespace_package',
        file_defs={
            'foo': {
                'bar': {'__init__.py': ''},
            },
        },
        setup_kwargs=dict(
            namespace_packages=['foo'],
            packages=['foo.bar'],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': [
                    'foo-1.0-py{py_version}-nspkg.pth',
                    {
                        'EGG-INFO': [
                            'PKG-INFO',
                            'RECORD',
                            'WHEEL',
                            'namespace_packages.txt',
                            'top_level.txt',
                        ]
                    },
                    {
                        'foo': [
                            '__init__.py',
                            {'bar': ['__init__.py']},
                        ]
                    },
                ]
            }
        ),
    ),
    dict(
        id='empty_namespace_package',
        file_defs={
            'foobar': {
                '__init__.py': (
                    "__import__('pkg_resources').declare_namespace(__name__)"
                )
            },
        },
        setup_kwargs=dict(
            namespace_packages=['foobar'],
            packages=['foobar'],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': [
                    'foo-1.0-py{py_version}-nspkg.pth',
                    {
                        'EGG-INFO': [
                            'PKG-INFO',
                            'RECORD',
                            'WHEEL',
                            'namespace_packages.txt',
                            'top_level.txt',
                        ]
                    },
                    {
                        'foobar': [
                            '__init__.py',
                        ]
                    },
                ]
            }
        ),
    ),
    dict(
        id='data_in_package',
        file_defs={
            'foo': {
                '__init__.py': '',
                'data_dir': {
                    'data.txt': DALS(
                        '''
                        Some data...
                        '''
                    ),
                },
            }
        },
        setup_kwargs=dict(
            packages=['foo'],
            data_files=[('foo/data_dir', ['foo/data_dir/data.txt'])],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': {
                    'EGG-INFO': [
                        'PKG-INFO',
                        'RECORD',
                        'WHEEL',
                        'top_level.txt',
                    ],
                    'foo': [
                        '__init__.py',
                        {
                            'data_dir': [
                                'data.txt',
                            ]
                        },
                    ],
                }
            }
        ),
    ),
)


@pytest.mark.parametrize(
    'params',
    WHEEL_INSTALL_TESTS,
    ids=list(params['id'] for params in WHEEL_INSTALL_TESTS),
)
def test_wheel_install(params):
    project_name = params.get('name', 'foo')
    version = params.get('version', '1.0')
    install_requires = params.get('install_requires', [])
    extras_require = params.get('extras_require', {})
    requires_txt = params.get('requires_txt', None)
    install_tree = params.get('install_tree')
    file_defs = params.get('file_defs', {})
    setup_kwargs = params.get('setup_kwargs', {})
    with build_wheel(
        name=project_name,
        version=version,
        install_requires=install_requires,
        extras_require=extras_require,
        extra_file_defs=file_defs,
        **setup_kwargs
    ) as filename, tempdir() as install_dir:
        _check_wheel_install(
            filename, install_dir, install_tree, project_name, version, requires_txt
        )


def test_wheel_install_pep_503():
    project_name = 'Foo_Bar'  # PEP 503 canonicalized name is "foo-bar"
    version = '1.0'
    with build_wheel(
        name=project_name,
        version=version,
    ) as filename, tempdir() as install_dir:
        new_filename = filename.replace(project_name, canonicalize_name(project_name))
        shutil.move(filename, new_filename)
        _check_wheel_install(
            new_filename,
            install_dir,
            None,
            canonicalize_name(project_name),
            version,
            None,
        )


def test_wheel_no_dist_dir():
    project_name = 'nodistinfo'
    version = '1.0'
    wheel_name = '{0}-{1}-py2.py3-none-any.whl'.format(project_name, version)
    with tempdir() as source_dir:
        wheel_path = os.path.join(source_dir, wheel_name)
        # create an empty zip file
        zipfile.ZipFile(wheel_path, 'w').close()
        with tempdir() as install_dir:
            with pytest.raises(ValueError):
                _check_wheel_install(
                    wheel_path, install_dir, None, project_name, version, None
                )


def test_wheel_is_compatible(monkeypatch):
    def sys_tags():
        return {
            (t.interpreter, t.abi, t.platform)
            for t in parse_tag('cp36-cp36m-manylinux1_x86_64')
        }

    monkeypatch.setattr('setuptools.wheel._get_supported_tags', sys_tags)
    assert Wheel('onnxruntime-0.1.2-cp36-cp36m-manylinux1_x86_64.whl').is_compatible()


def test_wheel_mode():
    @contextlib.contextmanager
    def build_wheel(extra_file_defs=None, **kwargs):
        file_defs = {
            'setup.py': (
                DALS(
                    '''
                # -*- coding: utf-8 -*-
                from setuptools import setup
                import setuptools
                setup(**%r)
                '''
                )
                % kwargs
            ).encode('utf-8'),
        }
        if extra_file_defs:
            file_defs.update(extra_file_defs)
        with tempdir() as source_dir:
            path.build(file_defs, source_dir)
            runsh = pathlib.Path(source_dir) / "script.sh"
            os.chmod(runsh, 0o777)
            subprocess.check_call(
                (sys.executable, 'setup.py', '-q', 'bdist_wheel'), cwd=source_dir
            )
            yield glob.glob(os.path.join(source_dir, 'dist', '*.whl'))[0]

    params = dict(
        id='script',
        file_defs={
            'script.py': DALS(
                '''
                #/usr/bin/python
                print('hello world!')
                '''
            ),
            'script.sh': DALS(
                '''
                #/bin/sh
                echo 'hello world!'
                '''
            ),
        },
        setup_kwargs=dict(
            scripts=['script.py', 'script.sh'],
        ),
        install_tree=flatten_tree(
            {
                'foo-1.0-py{py_version}.egg': {
                    'EGG-INFO': [
                        'PKG-INFO',
                        'RECORD',
                        'WHEEL',
                        'top_level.txt',
                        {'scripts': ['script.py', 'script.sh']},
                    ]
                }
            }
        ),
    )

    project_name = params.get('name', 'foo')
    version = params.get('version', '1.0')
    install_tree = params.get('install_tree')
    file_defs = params.get('file_defs', {})
    setup_kwargs = params.get('setup_kwargs', {})

    with build_wheel(
        name=project_name,
        version=version,
        install_requires=[],
        extras_require={},
        extra_file_defs=file_defs,
        **setup_kwargs
    ) as filename, tempdir() as install_dir:
        _check_wheel_install(
            filename, install_dir, install_tree, project_name, version, None
        )
        w = Wheel(filename)
        base = pathlib.Path(install_dir) / w.egg_name()
        script_sh = base / "EGG-INFO" / "scripts" / "script.sh"
        assert script_sh.exists()
        if sys.platform != 'win32':
            # Editable file mode has no effect on Windows
            assert oct(stat.S_IMODE(script_sh.stat().st_mode)) == "0o777"
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/test_windows_wrappers.py0000644000175100001730000001702314467657412024066 0ustar00runnerdocker"""
Python Script Wrapper for Windows
=================================

setuptools includes wrappers for Python scripts that allows them to be
executed like regular windows programs.  There are 2 wrappers, one
for command-line programs, cli.exe, and one for graphical programs,
gui.exe.  These programs are almost identical, function pretty much
the same way, and are generated from the same source file.  The
wrapper programs are used by copying them to the directory containing
the script they are to wrap and with the same name as the script they
are to wrap.
"""
import pathlib
import sys
import platform
import textwrap
import subprocess

import pytest

from setuptools.command.easy_install import nt_quote_arg
import pkg_resources

pytestmark = pytest.mark.skipif(sys.platform != 'win32', reason="Windows only")


class WrapperTester:
    @classmethod
    def prep_script(cls, template):
        python_exe = nt_quote_arg(sys.executable)
        return template % locals()

    @classmethod
    def create_script(cls, tmpdir):
        """
        Create a simple script, foo-script.py

        Note that the script starts with a Unix-style '#!' line saying which
        Python executable to run.  The wrapper will use this line to find the
        correct Python executable.
        """

        script = cls.prep_script(cls.script_tmpl)

        with (tmpdir / cls.script_name).open('w') as f:
            f.write(script)

        # also copy cli.exe to the sample directory
        with (tmpdir / cls.wrapper_name).open('wb') as f:
            w = pkg_resources.resource_string('setuptools', cls.wrapper_source)
            f.write(w)


def win_launcher_exe(prefix):
    """A simple routine to select launcher script based on platform."""
    assert prefix in ('cli', 'gui')
    if platform.machine() == "ARM64":
        return "{}-arm64.exe".format(prefix)
    else:
        return "{}-32.exe".format(prefix)


class TestCLI(WrapperTester):
    script_name = 'foo-script.py'
    wrapper_name = 'foo.exe'
    wrapper_source = win_launcher_exe('cli')

    script_tmpl = textwrap.dedent(
        """
        #!%(python_exe)s
        import sys
        input = repr(sys.stdin.read())
        print(sys.argv[0][-14:])
        print(sys.argv[1:])
        print(input)
        if __debug__:
            print('non-optimized')
        """
    ).lstrip()

    def test_basic(self, tmpdir):
        """
        When the copy of cli.exe, foo.exe in this example, runs, it examines
        the path name it was run with and computes a Python script path name
        by removing the '.exe' suffix and adding the '-script.py' suffix. (For
        GUI programs, the suffix '-script.pyw' is added.)  This is why we
        named out script the way we did.  Now we can run out script by running
        the wrapper:

        This example was a little pathological in that it exercised windows
        (MS C runtime) quoting rules:

        - Strings containing spaces are surrounded by double quotes.

        - Double quotes in strings need to be escaped by preceding them with
          back slashes.

        - One or more backslashes preceding double quotes need to be escaped
          by preceding each of them with back slashes.
        """
        self.create_script(tmpdir)
        cmd = [
            str(tmpdir / 'foo.exe'),
            'arg1',
            'arg 2',
            'arg "2\\"',
            'arg 4\\',
            'arg5 a\\\\b',
        ]
        proc = subprocess.Popen(
            cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, text=True
        )
        stdout, stderr = proc.communicate('hello\nworld\n')
        actual = stdout.replace('\r\n', '\n')
        expected = textwrap.dedent(
            r"""
            \foo-script.py
            ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
            'hello\nworld\n'
            non-optimized
            """
        ).lstrip()
        assert actual == expected

    def test_symlink(self, tmpdir):
        """
        Ensure that symlink for the foo.exe is working correctly.
        """
        script_dir = tmpdir / "script_dir"
        script_dir.mkdir()
        self.create_script(script_dir)
        symlink = pathlib.Path(tmpdir / "foo.exe")
        symlink.symlink_to(script_dir / "foo.exe")

        cmd = [
            str(tmpdir / 'foo.exe'),
            'arg1',
            'arg 2',
            'arg "2\\"',
            'arg 4\\',
            'arg5 a\\\\b',
        ]
        proc = subprocess.Popen(
            cmd, stdout=subprocess.PIPE, stdin=subprocess.PIPE, text=True
        )
        stdout, stderr = proc.communicate('hello\nworld\n')
        actual = stdout.replace('\r\n', '\n')
        expected = textwrap.dedent(
            r"""
            \foo-script.py
            ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
            'hello\nworld\n'
            non-optimized
            """
        ).lstrip()
        assert actual == expected

    def test_with_options(self, tmpdir):
        """
        Specifying Python Command-line Options
        --------------------------------------

        You can specify a single argument on the '#!' line.  This can be used
        to specify Python options like -O, to run in optimized mode or -i
        to start the interactive interpreter.  You can combine multiple
        options as usual. For example, to run in optimized mode and
        enter the interpreter after running the script, you could use -Oi:
        """
        self.create_script(tmpdir)
        tmpl = textwrap.dedent(
            """
            #!%(python_exe)s  -Oi
            import sys
            input = repr(sys.stdin.read())
            print(sys.argv[0][-14:])
            print(sys.argv[1:])
            print(input)
            if __debug__:
                print('non-optimized')
            sys.ps1 = '---'
            """
        ).lstrip()
        with (tmpdir / 'foo-script.py').open('w') as f:
            f.write(self.prep_script(tmpl))
        cmd = [str(tmpdir / 'foo.exe')]
        proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
        )
        stdout, stderr = proc.communicate()
        actual = stdout.replace('\r\n', '\n')
        expected = textwrap.dedent(
            r"""
            \foo-script.py
            []
            ''
            ---
            """
        ).lstrip()
        assert actual == expected


class TestGUI(WrapperTester):
    """
    Testing the GUI Version
    -----------------------
    """

    script_name = 'bar-script.pyw'
    wrapper_source = win_launcher_exe('gui')
    wrapper_name = 'bar.exe'

    script_tmpl = textwrap.dedent(
        """
        #!%(python_exe)s
        import sys
        f = open(sys.argv[1], 'wb')
        bytes_written = f.write(repr(sys.argv[2]).encode('utf-8'))
        f.close()
        """
    ).strip()

    def test_basic(self, tmpdir):
        """Test the GUI version with the simple script, bar-script.py"""
        self.create_script(tmpdir)

        cmd = [
            str(tmpdir / 'bar.exe'),
            str(tmpdir / 'test_output.txt'),
            'Test Argument',
        ]
        proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
        )
        stdout, stderr = proc.communicate()
        assert not stdout
        assert not stderr
        with (tmpdir / 'test_output.txt').open('rb') as f_out:
            actual = f_out.read().decode('ascii')
        assert actual == repr('Test Argument')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/text.py0000644000175100001730000000017314467657412020374 0ustar00runnerdockerclass Filenames:
    unicode = 'smörbröd.py'
    latin_1 = unicode.encode('latin-1')
    utf_8 = unicode.encode('utf-8')
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/tests/textwrap.py0000644000175100001730000000014214467657412021262 0ustar00runnerdockerimport textwrap


def DALS(s):
    "dedent and left-strip"
    return textwrap.dedent(s).lstrip()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/unicode_utils.py0000644000175100001730000000165514467657412021122 0ustar00runnerdockerimport unicodedata
import sys


# HFS Plus uses decomposed UTF-8
def decompose(path):
    if isinstance(path, str):
        return unicodedata.normalize('NFD', path)
    try:
        path = path.decode('utf-8')
        path = unicodedata.normalize('NFD', path)
        path = path.encode('utf-8')
    except UnicodeError:
        pass  # Not UTF-8
    return path


def filesys_decode(path):
    """
    Ensure that the given path is decoded,
    NONE when no expected encoding works
    """

    if isinstance(path, str):
        return path

    fs_enc = sys.getfilesystemencoding() or 'utf-8'
    candidates = fs_enc, 'utf-8'

    for enc in candidates:
        try:
            return path.decode(enc)
        except UnicodeDecodeError:
            continue


def try_encode(string, enc):
    "turn unicode encoding into a functional routine"
    try:
        return string.encode(enc)
    except UnicodeEncodeError:
        return None
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/version.py0000644000175100001730000000024114467657412017727 0ustar00runnerdockerfrom ._importlib import metadata

try:
    __version__ = metadata.version('setuptools') or '0.dev0+unknown'
except Exception:
    __version__ = '0.dev0+unknown'
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/warnings.py0000644000175100001730000000716114467657412020102 0ustar00runnerdocker"""Provide basic warnings used by setuptools modules.

Using custom classes (other than ``UserWarning``) allow users to set
``PYTHONWARNINGS`` filters to run tests and prepare for upcoming changes in
setuptools.
"""

import os
import warnings
from datetime import date
from inspect import cleandoc
from textwrap import indent
from typing import Optional, Tuple

_DueDate = Tuple[int, int, int]  # time tuple
_INDENT = 8 * " "
_TEMPLATE = f"""{80 * '*'}\n{{details}}\n{80 * '*'}"""


class SetuptoolsWarning(UserWarning):
    """Base class in ``setuptools`` warning hierarchy."""

    @classmethod
    def emit(
        cls,
        summary: Optional[str] = None,
        details: Optional[str] = None,
        due_date: Optional[_DueDate] = None,
        see_docs: Optional[str] = None,
        see_url: Optional[str] = None,
        stacklevel: int = 2,
        **kwargs,
    ):
        """Private: reserved for ``setuptools`` internal use only"""
        # Default values:
        summary_ = summary or getattr(cls, "_SUMMARY", None) or ""
        details_ = details or getattr(cls, "_DETAILS", None) or ""
        due_date = due_date or getattr(cls, "_DUE_DATE", None)
        docs_ref = see_docs or getattr(cls, "_SEE_DOCS", None)
        docs_url = docs_ref and f"https://setuptools.pypa.io/en/latest/{docs_ref}"
        see_url = see_url or getattr(cls, "_SEE_URL", None)
        due = date(*due_date) if due_date else None

        text = cls._format(summary_, details_, due, see_url or docs_url, kwargs)
        if due and due < date.today() and _should_enforce():
            raise cls(text)
        warnings.warn(text, cls, stacklevel=stacklevel + 1)

    @classmethod
    def _format(
        cls,
        summary: str,
        details: str,
        due_date: Optional[date] = None,
        see_url: Optional[str] = None,
        format_args: Optional[dict] = None,
    ):
        """Private: reserved for ``setuptools`` internal use only"""
        today = date.today()
        summary = cleandoc(summary).format_map(format_args or {})
        possible_parts = [
            cleandoc(details).format_map(format_args or {}),
            (
                f"\nBy {due_date:%Y-%b-%d}, you need to update your project and remove "
                "deprecated calls\nor your builds will no longer be supported."
                if due_date and due_date > today
                else None
            ),
            (
                "\nThis deprecation is overdue, please update your project and remove "
                "deprecated\ncalls to avoid build errors in the future."
                if due_date and due_date < today
                else None
            ),
            (f"\nSee {see_url} for details." if see_url else None),
        ]
        parts = [x for x in possible_parts if x]
        if parts:
            body = indent(_TEMPLATE.format(details="\n".join(parts)), _INDENT)
            return "\n".join([summary, "!!\n", body, "\n!!"])
        return summary


class InformationOnly(SetuptoolsWarning):
    """Currently there is no clear way of displaying messages to the users
    that use the setuptools backend directly via ``pip``.
    The only thing that might work is a warning, although it is not the
    most appropriate tool for the job...

    See pypa/packaging-problems#558.
    """


class SetuptoolsDeprecationWarning(SetuptoolsWarning):
    """
    Base class for warning deprecations in ``setuptools``

    This class is not derived from ``DeprecationWarning``, and as such is
    visible by default.
    """


def _should_enforce():
    enforce = os.getenv("SETUPTOOLS_ENFORCE_DEPRECATION", "false").lower()
    return enforce in ("true", "on", "ok", "1")
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/wheel.py0000644000175100001730000002066414467657412017361 0ustar00runnerdocker"""Wheels support."""

import email
import itertools
import functools
import os
import posixpath
import re
import zipfile
import contextlib

from distutils.util import get_platform

import setuptools
from setuptools.extern.packaging.version import Version as parse_version
from setuptools.extern.packaging.tags import sys_tags
from setuptools.extern.packaging.utils import canonicalize_name
from setuptools.command.egg_info import write_requirements, _egg_basename
from setuptools.archive_util import _unpack_zipfile_obj


WHEEL_NAME = re.compile(
    r"""^(?P.+?)-(?P\d.*?)
    ((-(?P\d.*?))?-(?P.+?)-(?P.+?)-(?P.+?)
    )\.whl$""",
    re.VERBOSE,
).match

NAMESPACE_PACKAGE_INIT = "__import__('pkg_resources').declare_namespace(__name__)\n"


@functools.lru_cache(maxsize=None)
def _get_supported_tags():
    # We calculate the supported tags only once, otherwise calling
    # this method on thousands of wheels takes seconds instead of
    # milliseconds.
    return {(t.interpreter, t.abi, t.platform) for t in sys_tags()}


def unpack(src_dir, dst_dir):
    '''Move everything under `src_dir` to `dst_dir`, and delete the former.'''
    for dirpath, dirnames, filenames in os.walk(src_dir):
        subdir = os.path.relpath(dirpath, src_dir)
        for f in filenames:
            src = os.path.join(dirpath, f)
            dst = os.path.join(dst_dir, subdir, f)
            os.renames(src, dst)
        for n, d in reversed(list(enumerate(dirnames))):
            src = os.path.join(dirpath, d)
            dst = os.path.join(dst_dir, subdir, d)
            if not os.path.exists(dst):
                # Directory does not exist in destination,
                # rename it and prune it from os.walk list.
                os.renames(src, dst)
                del dirnames[n]
    # Cleanup.
    for dirpath, dirnames, filenames in os.walk(src_dir, topdown=True):
        assert not filenames
        os.rmdir(dirpath)


@contextlib.contextmanager
def disable_info_traces():
    """
    Temporarily disable info traces.
    """
    from distutils import log

    saved = log.set_threshold(log.WARN)
    try:
        yield
    finally:
        log.set_threshold(saved)


class Wheel:
    def __init__(self, filename):
        match = WHEEL_NAME(os.path.basename(filename))
        if match is None:
            raise ValueError('invalid wheel name: %r' % filename)
        self.filename = filename
        for k, v in match.groupdict().items():
            setattr(self, k, v)

    def tags(self):
        '''List tags (py_version, abi, platform) supported by this wheel.'''
        return itertools.product(
            self.py_version.split('.'),
            self.abi.split('.'),
            self.platform.split('.'),
        )

    def is_compatible(self):
        '''Is the wheel compatible with the current platform?'''
        return next((True for t in self.tags() if t in _get_supported_tags()), False)

    def egg_name(self):
        return (
            _egg_basename(
                self.project_name,
                self.version,
                platform=(None if self.platform == 'any' else get_platform()),
            )
            + ".egg"
        )

    def get_dist_info(self, zf):
        # find the correct name of the .dist-info dir in the wheel file
        for member in zf.namelist():
            dirname = posixpath.dirname(member)
            if dirname.endswith('.dist-info') and canonicalize_name(dirname).startswith(
                canonicalize_name(self.project_name)
            ):
                return dirname
        raise ValueError("unsupported wheel format. .dist-info not found")

    def install_as_egg(self, destination_eggdir):
        '''Install wheel as an egg directory.'''
        with zipfile.ZipFile(self.filename) as zf:
            self._install_as_egg(destination_eggdir, zf)

    def _install_as_egg(self, destination_eggdir, zf):
        dist_basename = '%s-%s' % (self.project_name, self.version)
        dist_info = self.get_dist_info(zf)
        dist_data = '%s.data' % dist_basename
        egg_info = os.path.join(destination_eggdir, 'EGG-INFO')

        self._convert_metadata(zf, destination_eggdir, dist_info, egg_info)
        self._move_data_entries(destination_eggdir, dist_data)
        self._fix_namespace_packages(egg_info, destination_eggdir)

    @staticmethod
    def _convert_metadata(zf, destination_eggdir, dist_info, egg_info):
        import pkg_resources

        def get_metadata(name):
            with zf.open(posixpath.join(dist_info, name)) as fp:
                value = fp.read().decode('utf-8')
                return email.parser.Parser().parsestr(value)

        wheel_metadata = get_metadata('WHEEL')
        # Check wheel format version is supported.
        wheel_version = parse_version(wheel_metadata.get('Wheel-Version'))
        wheel_v1 = parse_version('1.0') <= wheel_version < parse_version('2.0dev0')
        if not wheel_v1:
            raise ValueError('unsupported wheel format version: %s' % wheel_version)
        # Extract to target directory.
        _unpack_zipfile_obj(zf, destination_eggdir)
        # Convert metadata.
        dist_info = os.path.join(destination_eggdir, dist_info)
        dist = pkg_resources.Distribution.from_location(
            destination_eggdir,
            dist_info,
            metadata=pkg_resources.PathMetadata(destination_eggdir, dist_info),
        )

        # Note: Evaluate and strip markers now,
        # as it's difficult to convert back from the syntax:
        # foobar; "linux" in sys_platform and extra == 'test'
        def raw_req(req):
            req.marker = None
            return str(req)

        install_requires = list(map(raw_req, dist.requires()))
        extras_require = {
            extra: [
                req
                for req in map(raw_req, dist.requires((extra,)))
                if req not in install_requires
            ]
            for extra in dist.extras
        }
        os.rename(dist_info, egg_info)
        os.rename(
            os.path.join(egg_info, 'METADATA'),
            os.path.join(egg_info, 'PKG-INFO'),
        )
        setup_dist = setuptools.Distribution(
            attrs=dict(
                install_requires=install_requires,
                extras_require=extras_require,
            ),
        )
        with disable_info_traces():
            write_requirements(
                setup_dist.get_command_obj('egg_info'),
                None,
                os.path.join(egg_info, 'requires.txt'),
            )

    @staticmethod
    def _move_data_entries(destination_eggdir, dist_data):
        """Move data entries to their correct location."""
        dist_data = os.path.join(destination_eggdir, dist_data)
        dist_data_scripts = os.path.join(dist_data, 'scripts')
        if os.path.exists(dist_data_scripts):
            egg_info_scripts = os.path.join(destination_eggdir, 'EGG-INFO', 'scripts')
            os.mkdir(egg_info_scripts)
            for entry in os.listdir(dist_data_scripts):
                # Remove bytecode, as it's not properly handled
                # during easy_install scripts install phase.
                if entry.endswith('.pyc'):
                    os.unlink(os.path.join(dist_data_scripts, entry))
                else:
                    os.rename(
                        os.path.join(dist_data_scripts, entry),
                        os.path.join(egg_info_scripts, entry),
                    )
            os.rmdir(dist_data_scripts)
        for subdir in filter(
            os.path.exists,
            (
                os.path.join(dist_data, d)
                for d in ('data', 'headers', 'purelib', 'platlib')
            ),
        ):
            unpack(subdir, destination_eggdir)
        if os.path.exists(dist_data):
            os.rmdir(dist_data)

    @staticmethod
    def _fix_namespace_packages(egg_info, destination_eggdir):
        namespace_packages = os.path.join(egg_info, 'namespace_packages.txt')
        if os.path.exists(namespace_packages):
            with open(namespace_packages) as fp:
                namespace_packages = fp.read().split()
            for mod in namespace_packages:
                mod_dir = os.path.join(destination_eggdir, *mod.split('.'))
                mod_init = os.path.join(mod_dir, '__init__.py')
                if not os.path.exists(mod_dir):
                    os.mkdir(mod_dir)
                if not os.path.exists(mod_init):
                    with open(mod_init, 'w') as fp:
                        fp.write(NAMESPACE_PACKAGE_INIT)
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/setuptools/windows_support.py0000644000175100001730000000131714467657412021535 0ustar00runnerdockerimport platform


def windows_only(func):
    if platform.system() != 'Windows':
        return lambda *args, **kwargs: None
    return func


@windows_only
def hide_file(path):
    """
    Set the hidden attribute on a file or directory.

    From http://stackoverflow.com/questions/19622133/

    `path` must be text.
    """
    import ctypes

    __import__('ctypes.wintypes')
    SetFileAttributes = ctypes.windll.kernel32.SetFileAttributesW
    SetFileAttributes.argtypes = ctypes.wintypes.LPWSTR, ctypes.wintypes.DWORD
    SetFileAttributes.restype = ctypes.wintypes.BOOL

    FILE_ATTRIBUTE_HIDDEN = 0x02

    ret = SetFileAttributes(path, FILE_ATTRIBUTE_HIDDEN)
    if not ret:
        raise ctypes.WinError()
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5075488
setuptools-68.1.2/setuptools.egg-info/0000755000175100001730000000000014467657444017372 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360483.0
setuptools-68.1.2/setuptools.egg-info/PKG-INFO0000644000175100001730000000673614467657443020502 0ustar00runnerdockerMetadata-Version: 2.1
Name: setuptools
Version: 68.1.2
Summary: Easily download, build, install, upgrade, and uninstall Python packages
Home-page: https://github.com/pypa/setuptools
Author: Python Packaging Authority
Author-email: distutils-sig@python.org
Project-URL: Documentation, https://setuptools.pypa.io/
Project-URL: Changelog, https://setuptools.pypa.io/en/stable/history.html
Keywords: CPAN PyPI distutils eggs package management
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: System :: Archiving :: Packaging
Classifier: Topic :: System :: Systems Administration
Classifier: Topic :: Utilities
Requires-Python: >=3.8
Provides-Extra: testing
Provides-Extra: testing-integration
Provides-Extra: docs
Provides-Extra: ssl
Provides-Extra: certs
License-File: LICENSE

.. image:: https://img.shields.io/pypi/v/setuptools.svg
   :target: https://pypi.org/project/setuptools

.. image:: https://img.shields.io/pypi/pyversions/setuptools.svg

.. image:: https://github.com/pypa/setuptools/workflows/tests/badge.svg
   :target: https://github.com/pypa/setuptools/actions?query=workflow%3A%22tests%22
   :alt: tests

.. image:: https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v2.json
    :target: https://github.com/astral-sh/ruff
    :alt: Ruff

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg
   :target: https://github.com/psf/black
   :alt: Code style: Black

.. image:: https://img.shields.io/readthedocs/setuptools/latest.svg
    :target: https://setuptools.pypa.io

.. image:: https://img.shields.io/badge/skeleton-2023-informational
   :target: https://blog.jaraco.com/skeleton

.. image:: https://img.shields.io/codecov/c/github/pypa/setuptools/master.svg?logo=codecov&logoColor=white
   :target: https://codecov.io/gh/pypa/setuptools

.. image:: https://tidelift.com/badges/github/pypa/setuptools?style=flat
   :target: https://tidelift.com/subscription/pkg/pypi-setuptools?utm_source=pypi-setuptools&utm_medium=readme

.. image:: https://img.shields.io/discord/803025117553754132
   :target: https://discord.com/channels/803025117553754132/815945031150993468
   :alt: Discord

See the `Installation Instructions
`_ in the Python Packaging
User's Guide for instructions on installing, upgrading, and uninstalling
Setuptools.

Questions and comments should be directed to `GitHub Discussions
`_.
Bug reports and especially tested patches may be
submitted directly to the `bug tracker
`_.


Code of Conduct
===============

Everyone interacting in the setuptools project's codebases, issue trackers,
chat rooms, and fora is expected to follow the
`PSF Code of Conduct `_.


For Enterprise
==============

Available as part of the Tidelift Subscription.

Setuptools and the maintainers of thousands of other packages are working with Tidelift to deliver one enterprise subscription that covers all of the open source you use.

`Learn more `_.
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360483.0
setuptools-68.1.2/setuptools.egg-info/SOURCES.txt0000644000175100001730000005000414467657443021254 0ustar00runnerdockerLICENSE
MANIFEST.in
NEWS.rst
README.rst
conftest.py
exercises.py
launcher.c
pyproject.toml
pytest.ini
setup.cfg
setup.py
tox.ini
_distutils_hack/__init__.py
_distutils_hack/override.py
docs/artwork.rst
docs/build_meta.rst
docs/conf.py
docs/history.rst
docs/index.rst
docs/pkg_resources.rst
docs/python 2 sunset.rst
docs/roadmap.rst
docs/setuptools.rst
docs/deprecated/changed_keywords.rst
docs/deprecated/commands.rst
docs/deprecated/dependency_links.rst
docs/deprecated/distutils-legacy.rst
docs/deprecated/easy_install.rst
docs/deprecated/functionalities.rst
docs/deprecated/index.rst
docs/deprecated/python_eggs.rst
docs/deprecated/resource_extraction.rst
docs/deprecated/zip_safe.rst
docs/deprecated/distutils/_setuptools_disclaimer.rst
docs/deprecated/distutils/apiref.rst
docs/deprecated/distutils/builtdist.rst
docs/deprecated/distutils/commandref.rst
docs/deprecated/distutils/configfile.rst
docs/deprecated/distutils/examples.rst
docs/deprecated/distutils/extending.rst
docs/deprecated/distutils/index.rst
docs/deprecated/distutils/introduction.rst
docs/deprecated/distutils/packageindex.rst
docs/deprecated/distutils/setupscript.rst
docs/deprecated/distutils/sourcedist.rst
docs/deprecated/distutils/uploading.rst
docs/development/developer-guide.rst
docs/development/index.rst
docs/development/releases.rst
docs/references/keywords.rst
docs/userguide/datafiles.rst
docs/userguide/declarative_config.rst
docs/userguide/dependency_management.rst
docs/userguide/development_mode.rst
docs/userguide/distribution.rst
docs/userguide/entry_point.rst
docs/userguide/ext_modules.rst
docs/userguide/extension.rst
docs/userguide/index.rst
docs/userguide/miscellaneous.rst
docs/userguide/package_discovery.rst
docs/userguide/pyproject_config.rst
docs/userguide/quickstart.rst
newsfragments/.gitignore
newsfragments/README.rst
pkg_resources/__init__.py
pkg_resources/api_tests.txt
pkg_resources/_vendor/__init__.py
pkg_resources/_vendor/typing_extensions.py
pkg_resources/_vendor/vendored.txt
pkg_resources/_vendor/zipp.py
pkg_resources/_vendor/importlib_resources/__init__.py
pkg_resources/_vendor/importlib_resources/_adapters.py
pkg_resources/_vendor/importlib_resources/_common.py
pkg_resources/_vendor/importlib_resources/_compat.py
pkg_resources/_vendor/importlib_resources/_itertools.py
pkg_resources/_vendor/importlib_resources/_legacy.py
pkg_resources/_vendor/importlib_resources/abc.py
pkg_resources/_vendor/importlib_resources/readers.py
pkg_resources/_vendor/importlib_resources/simple.py
pkg_resources/_vendor/importlib_resources-5.10.2.dist-info/top_level.txt
pkg_resources/_vendor/importlib_resources/tests/__init__.py
pkg_resources/_vendor/importlib_resources/tests/_compat.py
pkg_resources/_vendor/importlib_resources/tests/_path.py
pkg_resources/_vendor/importlib_resources/tests/test_compatibilty_files.py
pkg_resources/_vendor/importlib_resources/tests/test_contents.py
pkg_resources/_vendor/importlib_resources/tests/test_files.py
pkg_resources/_vendor/importlib_resources/tests/test_open.py
pkg_resources/_vendor/importlib_resources/tests/test_path.py
pkg_resources/_vendor/importlib_resources/tests/test_read.py
pkg_resources/_vendor/importlib_resources/tests/test_reader.py
pkg_resources/_vendor/importlib_resources/tests/test_resource.py
pkg_resources/_vendor/importlib_resources/tests/update-zips.py
pkg_resources/_vendor/importlib_resources/tests/util.py
pkg_resources/_vendor/importlib_resources/tests/data01/__init__.py
pkg_resources/_vendor/importlib_resources/tests/data01/subdirectory/__init__.py
pkg_resources/_vendor/importlib_resources/tests/data02/__init__.py
pkg_resources/_vendor/importlib_resources/tests/data02/one/__init__.py
pkg_resources/_vendor/importlib_resources/tests/data02/one/resource1.txt
pkg_resources/_vendor/importlib_resources/tests/data02/two/__init__.py
pkg_resources/_vendor/importlib_resources/tests/data02/two/resource2.txt
pkg_resources/_vendor/importlib_resources/tests/zipdata01/__init__.py
pkg_resources/_vendor/importlib_resources/tests/zipdata02/__init__.py
pkg_resources/_vendor/jaraco/__init__.py
pkg_resources/_vendor/jaraco/context.py
pkg_resources/_vendor/jaraco/functools.py
pkg_resources/_vendor/jaraco.context-4.3.0.dist-info/top_level.txt
pkg_resources/_vendor/jaraco.functools-3.6.0.dist-info/top_level.txt
pkg_resources/_vendor/jaraco.text-3.7.0.dist-info/top_level.txt
pkg_resources/_vendor/jaraco/text/Lorem ipsum.txt
pkg_resources/_vendor/jaraco/text/__init__.py
pkg_resources/_vendor/more_itertools/__init__.py
pkg_resources/_vendor/more_itertools/more.py
pkg_resources/_vendor/more_itertools/recipes.py
pkg_resources/_vendor/packaging/__init__.py
pkg_resources/_vendor/packaging/_elffile.py
pkg_resources/_vendor/packaging/_manylinux.py
pkg_resources/_vendor/packaging/_musllinux.py
pkg_resources/_vendor/packaging/_parser.py
pkg_resources/_vendor/packaging/_structures.py
pkg_resources/_vendor/packaging/_tokenizer.py
pkg_resources/_vendor/packaging/markers.py
pkg_resources/_vendor/packaging/metadata.py
pkg_resources/_vendor/packaging/requirements.py
pkg_resources/_vendor/packaging/specifiers.py
pkg_resources/_vendor/packaging/tags.py
pkg_resources/_vendor/packaging/utils.py
pkg_resources/_vendor/packaging/version.py
pkg_resources/_vendor/platformdirs/__init__.py
pkg_resources/_vendor/platformdirs/__main__.py
pkg_resources/_vendor/platformdirs/android.py
pkg_resources/_vendor/platformdirs/api.py
pkg_resources/_vendor/platformdirs/macos.py
pkg_resources/_vendor/platformdirs/unix.py
pkg_resources/_vendor/platformdirs/version.py
pkg_resources/_vendor/platformdirs/windows.py
pkg_resources/_vendor/zipp-3.7.0.dist-info/top_level.txt
pkg_resources/extern/__init__.py
pkg_resources/tests/__init__.py
pkg_resources/tests/test_find_distributions.py
pkg_resources/tests/test_markers.py
pkg_resources/tests/test_pkg_resources.py
pkg_resources/tests/test_resources.py
pkg_resources/tests/test_working_set.py
pkg_resources/tests/data/my-test-package-source/setup.cfg
pkg_resources/tests/data/my-test-package-source/setup.py
pkg_resources/tests/data/my-test-package-zip/my-test-package.zip
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/PKG-INFO
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/SOURCES.txt
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/dependency_links.txt
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/top_level.txt
pkg_resources/tests/data/my-test-package_unpacked-egg/my_test_package-1.0-py3.7.egg/EGG-INFO/zip-safe
pkg_resources/tests/data/my-test-package_zipped-egg/my_test_package-1.0-py3.7.egg
setuptools/__init__.py
setuptools/_entry_points.py
setuptools/_imp.py
setuptools/_importlib.py
setuptools/_itertools.py
setuptools/_normalization.py
setuptools/_path.py
setuptools/_reqs.py
setuptools/archive_util.py
setuptools/build_meta.py
setuptools/cli-32.exe
setuptools/cli-64.exe
setuptools/cli-arm64.exe
setuptools/cli.exe
setuptools/dep_util.py
setuptools/depends.py
setuptools/discovery.py
setuptools/dist.py
setuptools/errors.py
setuptools/extension.py
setuptools/glob.py
setuptools/gui-32.exe
setuptools/gui-64.exe
setuptools/gui-arm64.exe
setuptools/gui.exe
setuptools/installer.py
setuptools/launch.py
setuptools/logging.py
setuptools/monkey.py
setuptools/msvc.py
setuptools/namespaces.py
setuptools/package_index.py
setuptools/py312compat.py
setuptools/sandbox.py
setuptools/script (dev).tmpl
setuptools/script.tmpl
setuptools/unicode_utils.py
setuptools/version.py
setuptools/warnings.py
setuptools/wheel.py
setuptools/windows_support.py
setuptools.egg-info/PKG-INFO
setuptools.egg-info/SOURCES.txt
setuptools.egg-info/dependency_links.txt
setuptools.egg-info/entry_points.txt
setuptools.egg-info/requires.txt
setuptools.egg-info/top_level.txt
setuptools/_distutils/__init__.py
setuptools/_distutils/_collections.py
setuptools/_distutils/_functools.py
setuptools/_distutils/_log.py
setuptools/_distutils/_macos_compat.py
setuptools/_distutils/_msvccompiler.py
setuptools/_distutils/archive_util.py
setuptools/_distutils/bcppcompiler.py
setuptools/_distutils/ccompiler.py
setuptools/_distutils/cmd.py
setuptools/_distutils/config.py
setuptools/_distutils/core.py
setuptools/_distutils/cygwinccompiler.py
setuptools/_distutils/debug.py
setuptools/_distutils/dep_util.py
setuptools/_distutils/dir_util.py
setuptools/_distutils/dist.py
setuptools/_distutils/errors.py
setuptools/_distutils/extension.py
setuptools/_distutils/fancy_getopt.py
setuptools/_distutils/file_util.py
setuptools/_distutils/filelist.py
setuptools/_distutils/log.py
setuptools/_distutils/msvc9compiler.py
setuptools/_distutils/msvccompiler.py
setuptools/_distutils/py38compat.py
setuptools/_distutils/py39compat.py
setuptools/_distutils/spawn.py
setuptools/_distutils/sysconfig.py
setuptools/_distutils/text_file.py
setuptools/_distutils/unixccompiler.py
setuptools/_distutils/util.py
setuptools/_distutils/version.py
setuptools/_distutils/versionpredicate.py
setuptools/_distutils/command/__init__.py
setuptools/_distutils/command/_framework_compat.py
setuptools/_distutils/command/bdist.py
setuptools/_distutils/command/bdist_dumb.py
setuptools/_distutils/command/bdist_rpm.py
setuptools/_distutils/command/build.py
setuptools/_distutils/command/build_clib.py
setuptools/_distutils/command/build_ext.py
setuptools/_distutils/command/build_py.py
setuptools/_distutils/command/build_scripts.py
setuptools/_distutils/command/check.py
setuptools/_distutils/command/clean.py
setuptools/_distutils/command/config.py
setuptools/_distutils/command/install.py
setuptools/_distutils/command/install_data.py
setuptools/_distutils/command/install_egg_info.py
setuptools/_distutils/command/install_headers.py
setuptools/_distutils/command/install_lib.py
setuptools/_distutils/command/install_scripts.py
setuptools/_distutils/command/py37compat.py
setuptools/_distutils/command/register.py
setuptools/_distutils/command/sdist.py
setuptools/_distutils/command/upload.py
setuptools/_distutils/command/wininst-10.0-amd64.exe
setuptools/_distutils/command/wininst-10.0.exe
setuptools/_distutils/command/wininst-14.0-amd64.exe
setuptools/_distutils/command/wininst-14.0.exe
setuptools/_distutils/command/wininst-6.0.exe
setuptools/_distutils/command/wininst-7.1.exe
setuptools/_distutils/command/wininst-8.0.exe
setuptools/_distutils/command/wininst-9.0-amd64.exe
setuptools/_distutils/command/wininst-9.0.exe
setuptools/_distutils/tests/__init__.py
setuptools/_distutils/tests/py37compat.py
setuptools/_distutils/tests/py38compat.py
setuptools/_distutils/tests/support.py
setuptools/_distutils/tests/test_archive_util.py
setuptools/_distutils/tests/test_bdist.py
setuptools/_distutils/tests/test_bdist_dumb.py
setuptools/_distutils/tests/test_bdist_rpm.py
setuptools/_distutils/tests/test_build.py
setuptools/_distutils/tests/test_build_clib.py
setuptools/_distutils/tests/test_build_ext.py
setuptools/_distutils/tests/test_build_py.py
setuptools/_distutils/tests/test_build_scripts.py
setuptools/_distutils/tests/test_ccompiler.py
setuptools/_distutils/tests/test_check.py
setuptools/_distutils/tests/test_clean.py
setuptools/_distutils/tests/test_cmd.py
setuptools/_distutils/tests/test_config.py
setuptools/_distutils/tests/test_config_cmd.py
setuptools/_distutils/tests/test_core.py
setuptools/_distutils/tests/test_cygwinccompiler.py
setuptools/_distutils/tests/test_dep_util.py
setuptools/_distutils/tests/test_dir_util.py
setuptools/_distutils/tests/test_dist.py
setuptools/_distutils/tests/test_extension.py
setuptools/_distutils/tests/test_file_util.py
setuptools/_distutils/tests/test_filelist.py
setuptools/_distutils/tests/test_install.py
setuptools/_distutils/tests/test_install_data.py
setuptools/_distutils/tests/test_install_headers.py
setuptools/_distutils/tests/test_install_lib.py
setuptools/_distutils/tests/test_install_scripts.py
setuptools/_distutils/tests/test_log.py
setuptools/_distutils/tests/test_msvc9compiler.py
setuptools/_distutils/tests/test_msvccompiler.py
setuptools/_distutils/tests/test_register.py
setuptools/_distutils/tests/test_sdist.py
setuptools/_distutils/tests/test_spawn.py
setuptools/_distutils/tests/test_sysconfig.py
setuptools/_distutils/tests/test_text_file.py
setuptools/_distutils/tests/test_unixccompiler.py
setuptools/_distutils/tests/test_upload.py
setuptools/_distutils/tests/test_util.py
setuptools/_distutils/tests/test_version.py
setuptools/_distutils/tests/test_versionpredicate.py
setuptools/_distutils/tests/unix_compat.py
setuptools/_vendor/__init__.py
setuptools/_vendor/ordered_set.py
setuptools/_vendor/typing_extensions.py
setuptools/_vendor/vendored.txt
setuptools/_vendor/zipp.py
setuptools/_vendor/importlib_metadata/__init__.py
setuptools/_vendor/importlib_metadata/_adapters.py
setuptools/_vendor/importlib_metadata/_collections.py
setuptools/_vendor/importlib_metadata/_compat.py
setuptools/_vendor/importlib_metadata/_functools.py
setuptools/_vendor/importlib_metadata/_itertools.py
setuptools/_vendor/importlib_metadata/_meta.py
setuptools/_vendor/importlib_metadata/_py39compat.py
setuptools/_vendor/importlib_metadata/_text.py
setuptools/_vendor/importlib_metadata-6.0.0.dist-info/top_level.txt
setuptools/_vendor/importlib_resources/__init__.py
setuptools/_vendor/importlib_resources/_adapters.py
setuptools/_vendor/importlib_resources/_common.py
setuptools/_vendor/importlib_resources/_compat.py
setuptools/_vendor/importlib_resources/_itertools.py
setuptools/_vendor/importlib_resources/_legacy.py
setuptools/_vendor/importlib_resources/abc.py
setuptools/_vendor/importlib_resources/readers.py
setuptools/_vendor/importlib_resources/simple.py
setuptools/_vendor/importlib_resources-5.10.2.dist-info/top_level.txt
setuptools/_vendor/importlib_resources/tests/__init__.py
setuptools/_vendor/importlib_resources/tests/_compat.py
setuptools/_vendor/importlib_resources/tests/_path.py
setuptools/_vendor/importlib_resources/tests/test_compatibilty_files.py
setuptools/_vendor/importlib_resources/tests/test_contents.py
setuptools/_vendor/importlib_resources/tests/test_files.py
setuptools/_vendor/importlib_resources/tests/test_open.py
setuptools/_vendor/importlib_resources/tests/test_path.py
setuptools/_vendor/importlib_resources/tests/test_read.py
setuptools/_vendor/importlib_resources/tests/test_reader.py
setuptools/_vendor/importlib_resources/tests/test_resource.py
setuptools/_vendor/importlib_resources/tests/update-zips.py
setuptools/_vendor/importlib_resources/tests/util.py
setuptools/_vendor/importlib_resources/tests/data01/__init__.py
setuptools/_vendor/importlib_resources/tests/data01/subdirectory/__init__.py
setuptools/_vendor/importlib_resources/tests/data02/__init__.py
setuptools/_vendor/importlib_resources/tests/data02/one/__init__.py
setuptools/_vendor/importlib_resources/tests/data02/one/resource1.txt
setuptools/_vendor/importlib_resources/tests/data02/two/__init__.py
setuptools/_vendor/importlib_resources/tests/data02/two/resource2.txt
setuptools/_vendor/importlib_resources/tests/zipdata01/__init__.py
setuptools/_vendor/importlib_resources/tests/zipdata02/__init__.py
setuptools/_vendor/jaraco/__init__.py
setuptools/_vendor/jaraco/context.py
setuptools/_vendor/jaraco/functools.py
setuptools/_vendor/jaraco.context-4.3.0.dist-info/top_level.txt
setuptools/_vendor/jaraco.functools-3.6.0.dist-info/top_level.txt
setuptools/_vendor/jaraco.text-3.7.0.dist-info/top_level.txt
setuptools/_vendor/jaraco/text/Lorem ipsum.txt
setuptools/_vendor/jaraco/text/__init__.py
setuptools/_vendor/more_itertools/__init__.py
setuptools/_vendor/more_itertools/more.py
setuptools/_vendor/more_itertools/recipes.py
setuptools/_vendor/more_itertools-8.8.0.dist-info/top_level.txt
setuptools/_vendor/ordered_set-3.1.1.dist-info/top_level.txt
setuptools/_vendor/packaging/__init__.py
setuptools/_vendor/packaging/_elffile.py
setuptools/_vendor/packaging/_manylinux.py
setuptools/_vendor/packaging/_musllinux.py
setuptools/_vendor/packaging/_parser.py
setuptools/_vendor/packaging/_structures.py
setuptools/_vendor/packaging/_tokenizer.py
setuptools/_vendor/packaging/markers.py
setuptools/_vendor/packaging/metadata.py
setuptools/_vendor/packaging/requirements.py
setuptools/_vendor/packaging/specifiers.py
setuptools/_vendor/packaging/tags.py
setuptools/_vendor/packaging/utils.py
setuptools/_vendor/packaging/version.py
setuptools/_vendor/tomli/__init__.py
setuptools/_vendor/tomli/_parser.py
setuptools/_vendor/tomli/_re.py
setuptools/_vendor/tomli/_types.py
setuptools/_vendor/zipp-3.7.0.dist-info/top_level.txt
setuptools/command/__init__.py
setuptools/command/alias.py
setuptools/command/bdist_egg.py
setuptools/command/bdist_rpm.py
setuptools/command/build.py
setuptools/command/build_clib.py
setuptools/command/build_ext.py
setuptools/command/build_py.py
setuptools/command/develop.py
setuptools/command/dist_info.py
setuptools/command/easy_install.py
setuptools/command/editable_wheel.py
setuptools/command/egg_info.py
setuptools/command/install.py
setuptools/command/install_egg_info.py
setuptools/command/install_lib.py
setuptools/command/install_scripts.py
setuptools/command/launcher manifest.xml
setuptools/command/register.py
setuptools/command/rotate.py
setuptools/command/saveopts.py
setuptools/command/sdist.py
setuptools/command/setopt.py
setuptools/command/test.py
setuptools/command/upload.py
setuptools/command/upload_docs.py
setuptools/config/__init__.py
setuptools/config/_apply_pyprojecttoml.py
setuptools/config/expand.py
setuptools/config/pyprojecttoml.py
setuptools/config/setupcfg.py
setuptools/config/_validate_pyproject/__init__.py
setuptools/config/_validate_pyproject/error_reporting.py
setuptools/config/_validate_pyproject/extra_validations.py
setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py
setuptools/config/_validate_pyproject/fastjsonschema_validations.py
setuptools/config/_validate_pyproject/formats.py
setuptools/extern/__init__.py
setuptools/tests/__init__.py
setuptools/tests/contexts.py
setuptools/tests/environment.py
setuptools/tests/fixtures.py
setuptools/tests/mod_with_constant.py
setuptools/tests/namespaces.py
setuptools/tests/script-with-bom.py
setuptools/tests/server.py
setuptools/tests/test_archive_util.py
setuptools/tests/test_bdist_deprecations.py
setuptools/tests/test_bdist_egg.py
setuptools/tests/test_build.py
setuptools/tests/test_build_clib.py
setuptools/tests/test_build_ext.py
setuptools/tests/test_build_meta.py
setuptools/tests/test_build_py.py
setuptools/tests/test_config_discovery.py
setuptools/tests/test_dep_util.py
setuptools/tests/test_depends.py
setuptools/tests/test_develop.py
setuptools/tests/test_dist.py
setuptools/tests/test_dist_info.py
setuptools/tests/test_distutils_adoption.py
setuptools/tests/test_easy_install.py
setuptools/tests/test_editable_install.py
setuptools/tests/test_egg_info.py
setuptools/tests/test_extern.py
setuptools/tests/test_find_packages.py
setuptools/tests/test_find_py_modules.py
setuptools/tests/test_glob.py
setuptools/tests/test_install_scripts.py
setuptools/tests/test_integration.py
setuptools/tests/test_logging.py
setuptools/tests/test_manifest.py
setuptools/tests/test_msvc14.py
setuptools/tests/test_namespaces.py
setuptools/tests/test_packageindex.py
setuptools/tests/test_register.py
setuptools/tests/test_sandbox.py
setuptools/tests/test_sdist.py
setuptools/tests/test_setopt.py
setuptools/tests/test_setuptools.py
setuptools/tests/test_test.py
setuptools/tests/test_unicode_utils.py
setuptools/tests/test_upload.py
setuptools/tests/test_virtualenv.py
setuptools/tests/test_warnings.py
setuptools/tests/test_wheel.py
setuptools/tests/test_windows_wrappers.py
setuptools/tests/text.py
setuptools/tests/textwrap.py
setuptools/tests/config/__init__.py
setuptools/tests/config/setupcfg_examples.txt
setuptools/tests/config/test_apply_pyprojecttoml.py
setuptools/tests/config/test_expand.py
setuptools/tests/config/test_pyprojecttoml.py
setuptools/tests/config/test_pyprojecttoml_dynamic_deps.py
setuptools/tests/config/test_setupcfg.py
setuptools/tests/config/downloads/__init__.py
setuptools/tests/config/downloads/preload.py
setuptools/tests/indexes/test_links_priority/external.html
setuptools/tests/indexes/test_links_priority/simple/foobar/index.html
setuptools/tests/integration/__init__.py
setuptools/tests/integration/helpers.py
setuptools/tests/integration/test_pip_install_sdist.py
tools/build_launchers.py
tools/finalize.py
tools/generate_validation_code.py
tools/ppc64le-patch.py
tools/vendored.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360483.0
setuptools-68.1.2/setuptools.egg-info/dependency_links.txt0000644000175100001730000000000114467657443023437 0ustar00runnerdocker
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360483.0
setuptools-68.1.2/setuptools.egg-info/entry_points.txt0000644000175100001730000000516414467657443022675 0ustar00runnerdocker[distutils.commands]
alias = setuptools.command.alias:alias
bdist_egg = setuptools.command.bdist_egg:bdist_egg
bdist_rpm = setuptools.command.bdist_rpm:bdist_rpm
build = setuptools.command.build:build
build_clib = setuptools.command.build_clib:build_clib
build_ext = setuptools.command.build_ext:build_ext
build_py = setuptools.command.build_py:build_py
develop = setuptools.command.develop:develop
dist_info = setuptools.command.dist_info:dist_info
easy_install = setuptools.command.easy_install:easy_install
editable_wheel = setuptools.command.editable_wheel:editable_wheel
egg_info = setuptools.command.egg_info:egg_info
install = setuptools.command.install:install
install_egg_info = setuptools.command.install_egg_info:install_egg_info
install_lib = setuptools.command.install_lib:install_lib
install_scripts = setuptools.command.install_scripts:install_scripts
rotate = setuptools.command.rotate:rotate
saveopts = setuptools.command.saveopts:saveopts
sdist = setuptools.command.sdist:sdist
setopt = setuptools.command.setopt:setopt
test = setuptools.command.test:test
upload_docs = setuptools.command.upload_docs:upload_docs

[distutils.setup_keywords]
dependency_links = setuptools.dist:assert_string_list
eager_resources = setuptools.dist:assert_string_list
entry_points = setuptools.dist:check_entry_points
exclude_package_data = setuptools.dist:check_package_data
extras_require = setuptools.dist:check_extras
include_package_data = setuptools.dist:assert_bool
install_requires = setuptools.dist:check_requirements
namespace_packages = setuptools.dist:check_nsp
package_data = setuptools.dist:check_package_data
packages = setuptools.dist:check_packages
python_requires = setuptools.dist:check_specifier
setup_requires = setuptools.dist:check_requirements
test_loader = setuptools.dist:check_importable
test_runner = setuptools.dist:check_importable
test_suite = setuptools.dist:check_test_suite
tests_require = setuptools.dist:check_requirements
use_2to3 = setuptools.dist:invalid_unless_false
zip_safe = setuptools.dist:assert_bool

[egg_info.writers]
PKG-INFO = setuptools.command.egg_info:write_pkg_info
dependency_links.txt = setuptools.command.egg_info:overwrite_arg
eager_resources.txt = setuptools.command.egg_info:overwrite_arg
entry_points.txt = setuptools.command.egg_info:write_entries
namespace_packages.txt = setuptools.command.egg_info:overwrite_arg
requires.txt = setuptools.command.egg_info:write_requirements
top_level.txt = setuptools.command.egg_info:write_toplevel_names

[setuptools.finalize_distribution_options]
keywords = setuptools.dist:Distribution._finalize_setup_keywords
parent_finalize = setuptools.dist:_Distribution.finalize_options
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360483.0
setuptools-68.1.2/setuptools.egg-info/requires.txt0000644000175100001730000000163314467657443021774 0ustar00runnerdocker
[certs]

[docs]
sphinx<=7.1.2,>=3.5
jaraco.packaging>=9.3
rst.linker>=1.9
furo
sphinx-lint
jaraco.tidelift>=1.4
pygments-github-lexers==0.0.5
sphinx-favicon
sphinx-inline-tabs
sphinx-reredirects
sphinxcontrib-towncrier
sphinx-notfound-page==0.8.3
sphinx-hoverxref<2

[ssl]

[testing]
pytest>=6
pytest-checkdocs>=2.4
pytest-enabler>=2.2
flake8-2020
virtualenv>=13.0.0
wheel
pip>=19.1
jaraco.envs>=2.2
pytest-xdist
jaraco.path>=3.2.0
build[virtualenv]
filelock>=3.4.0
ini2toml[lite]>=0.9
tomli-w>=1.0.0
pytest-timeout

[testing-integration]
pytest
pytest-xdist
pytest-enabler
virtualenv>=13.0.0
tomli
wheel
jaraco.path>=3.2.0
jaraco.envs>=2.2
build[virtualenv]
filelock>=3.4.0

[testing:platform_python_implementation != "PyPy"]
pytest-black>=0.3.7
pytest-cov
pytest-mypy>=0.9.1

[testing:python_version >= "3.9" and sys_platform != "cygwin"]
jaraco.develop>=7.21

[testing:sys_platform != "cygwin"]
pytest-ruff
pytest-perf
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360483.0
setuptools-68.1.2/setuptools.egg-info/top_level.txt0000644000175100001730000000005114467657443022117 0ustar00runnerdocker_distutils_hack
pkg_resources
setuptools
././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1692360483.5595517
setuptools-68.1.2/tools/0000755000175100001730000000000014467657444014617 5ustar00runnerdocker././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/tools/build_launchers.py0000644000175100001730000001171514467657412020334 0ustar00runnerdocker"""
Build executable launchers for Windows.

Build module requires installation of
`CMake `_ and Visual Studio.

Please ensure that buildtools v143 or later are installed for Visual
Studio. Ensure that you install ARM build tools.

From Visual Studio Installer:
Visual Studio -> Modify -> Individual Components

List of components needed to install to compile on ARM:
- C++ Universal Windows Platform Support for v143 build Tools (ARM64)
- MSVC v143 - VS 2022 C++ ARM64 build tools (latest)
- MSVC v143 - VS 2022 C++ ARM64 Spectre-mitigated libs (latest)
- C++ ATL for latest v143 build tools (ARM64)
"""

import os
import functools
import itertools
import pathlib
import shutil
import subprocess
import tempfile


BUILD_TARGETS = ["cli", "gui"]
GUI = {"cli": 0, "gui": 1}
BUILD_PLATFORMS = ["Win32", "x64", "arm64"]
REPO_ROOT = pathlib.Path(__file__).parent.parent.resolve()
LAUNCHER_CMAKE_PROJECT = REPO_ROOT / "launcher"
MSBUILD_OUT_DIR = REPO_ROOT / "setuptools"
VISUAL_STUDIO_VERSION = "Visual Studio 17 2022"
"""
Version of Visual Studio that is currently installed on the machine.
Not tested with the older visual studios less then 16 version.
Generators
* Visual Studio 17 2022        = Generates Visual Studio 2022 project files.
                                 Use -A option to specify architecture.
  Visual Studio 16 2019        = Generates Visual Studio 2019 project files.
                                 Use -A option to specify architecture.
  Visual Studio 15 2017 [arch] = Generates Visual Studio 2017 project files.
                                 Optional [arch] can be "Win64" or "ARM".
  Visual Studio 14 2015 [arch] = Generates Visual Studio 2015 project files.
                                 Optional [arch] can be "Win64" or "ARM".
  Visual Studio 12 2013 [arch] = Generates Visual Studio 2013 project files.
                                 Optional [arch] can be "Win64" or "ARM".
  Visual Studio 11 2012 [arch] = Deprecated.  Generates Visual Studio 2012
                                 project files.  Optional [arch] can be
                                 "Win64" or "ARM".
  Visual Studio 9 2008 [arch]  = Generates Visual Studio 2008 project files.
                                 Optional [arch] can be "Win64" or "IA64".
"""


def resolve_platform(platform: str):
    if platform in ["Win32", "x64"]:
        return platform[-2:]
    return platform


def get_executable_name(name, platform: str):
    return f"{name}-{resolve_platform(platform)}"


def generate_cmake_project(build_arena, cmake_project_path, platform, is_gui):
    cmd = [
        get_cmake(),
        '-G',
        VISUAL_STUDIO_VERSION,
        '-A',
        platform,
        cmake_project_path,
        f'-DGUI={is_gui}',
    ]
    subprocess.check_call(cmd, cwd=build_arena)


def build_cmake_project_with_msbuild(build_arena, msbuild_parameters):
    cmd = [
        get_msbuild(),
        'launcher.vcxproj',
    ] + msbuild_parameters
    subprocess.check_call(cmd, cwd=build_arena)


@functools.lru_cache()
def get_cmake():
    """Find CMake using registry."""
    import winreg

    with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SOFTWARE\Kitware\CMake") as key:
        root = pathlib.Path(winreg.QueryValueEx(key, "InstallDir")[0])
    return root / 'bin\\CMake.exe'


@functools.lru_cache()
def get_msbuild():
    """Use VSWhere to find MSBuild."""
    vswhere = pathlib.Path(
        os.environ['ProgramFiles(x86)'],
        'Microsoft Visual Studio',
        'Installer',
        'vswhere.exe',
    )
    cmd = [
        vswhere,
        '-latest',
        '-prerelease',
        '-products',
        '*',
        '-requires',
        'Microsoft.Component.MSBuild',
        '-find',
        r'MSBuild\**\Bin\MSBuild.exe',
    ]
    try:
        return subprocess.check_output(cmd, encoding='utf-8', text=True).strip()
    except subprocess.CalledProcessError:
        raise SystemExit("Unable to find MSBuild; check Visual Studio install")


def do_build(arena, platform, target):
    print(f"Building {target} for {platform}")

    generate_cmake_project(arena, LAUNCHER_CMAKE_PROJECT, platform, GUI[target])

    build_params = [
        '/t:build',
        '/property:Configuration=Release',
        f'/property:Platform={platform}',
        f'/p:OutDir={MSBUILD_OUT_DIR.resolve()}',
        f'/p:TargetName={get_executable_name(target, platform)}',
    ]
    build_cmake_project_with_msbuild(arena, build_params)


def main():
    # check for executables early
    get_cmake()
    get_msbuild()

    for platform, target in itertools.product(BUILD_PLATFORMS, BUILD_TARGETS):
        with tempfile.TemporaryDirectory(dir=REPO_ROOT) as arena:
            do_build(arena, platform, target)

    # copy win32 as default executables
    for target in BUILD_TARGETS:
        executable = MSBUILD_OUT_DIR / f"{get_executable_name(target, 'Win32')}.exe"
        destination_executable = MSBUILD_OUT_DIR / f"{target}.exe"
        shutil.copy(executable, destination_executable)


if __name__ == "__main__":
    main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/tools/finalize.py0000644000175100001730000000260514467657412016770 0ustar00runnerdocker"""
Finalize the repo for a release. Invokes towncrier and bumpversion.
"""

__requires__ = ['bump2version', 'towncrier', 'jaraco.develop>=7.21']


import subprocess
import pathlib
import re
import sys

from jaraco.develop import towncrier


bump_version_command = [
    sys.executable,
    '-m',
    'bumpversion',
    towncrier.release_kind(),
]


def get_version():
    cmd = bump_version_command + ['--dry-run', '--verbose']
    out = subprocess.check_output(cmd, text=True)
    return re.search('^new_version=(.*)', out, re.MULTILINE).group(1)


def update_changelog():
    towncrier.run('build', '--yes')
    _repair_changelog()


def _repair_changelog():
    """
    Workaround for #2666
    """
    changelog_fn = pathlib.Path('NEWS.rst')
    changelog = changelog_fn.read_text(encoding='utf-8')
    fixed = re.sub(r'^(v[0-9.]+)v[0-9.]+$', r'\1', changelog, flags=re.M)
    changelog_fn.write_text(fixed, encoding='utf-8')
    subprocess.check_output(['git', 'add', changelog_fn])


def bump_version():
    cmd = bump_version_command + ['--allow-dirty']
    subprocess.check_call(cmd)


def ensure_config():
    """
    Double-check that Git has an e-mail configured.
    """
    subprocess.check_output(['git', 'config', 'user.email'])


if __name__ == '__main__':
    print("Cutting release at", get_version())
    ensure_config()
    towncrier.check_changes()
    update_changelog()
    bump_version()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/tools/generate_validation_code.py0000644000175100001730000000124514467657412022164 0ustar00runnerdockerimport subprocess
import sys

from pathlib import Path


def generate_pyproject_validation(dest: Path):
    """
    Generates validation code for ``pyproject.toml`` based on JSON schemas and the
    ``validate-pyproject`` library.
    """
    cmd = [
        sys.executable,
        "-m",
        "validate_pyproject.vendoring",
        f"--output-dir={dest}",
        "--enable-plugins",
        "setuptools",
        "distutils",
        "--very-verbose",
    ]
    subprocess.check_call(cmd)
    print(f"Validation code generated at: {dest}")


def main():
    generate_pyproject_validation(Path("setuptools/config/_validate_pyproject"))


__name__ == '__main__' and main()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/tools/ppc64le-patch.py0000644000175100001730000000123014467657412017532 0ustar00runnerdocker"""
Except on bionic, Travis Linux base image for PPC64LE
platform lacks the proper
permissions to the directory ~/.cache/pip/wheels that allow
the user running travis build to install pip packages.
TODO: is someone tracking this issue? Maybe just move to bionic?
"""

import subprocess
import collections
import os


def patch():
    env = collections.defaultdict(str, os.environ)
    if env['TRAVIS_CPU_ARCH'] != 'ppc64le':
        return
    cmd = [
        'sudo',
        'chown',
        '-Rfv',
        '{USER}:{GROUP}'.format_map(env),
        os.path.expanduser('~/.cache/pip/wheels'),
    ]
    subprocess.Popen(cmd)


__name__ == '__main__' and patch()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/tools/vendored.py0000644000175100001730000001104614467657412016774 0ustar00runnerdockerimport re
import sys
import subprocess

from path import Path


def remove_all(paths):
    for path in paths:
        path.rmtree() if path.isdir() else path.remove()


def update_vendored():
    update_pkg_resources()
    update_setuptools()


def rewrite_packaging(pkg_files, new_root):
    """
    Rewrite imports in packaging to redirect to vendored copies.
    """
    for file in pkg_files.glob('*.py'):
        text = file.text()
        text = re.sub(r' (pyparsing)', rf' {new_root}.\1', text)
        text = text.replace(
            'from six.moves.urllib import parse',
            'from urllib import parse',
        )
        file.write_text(text)


def rewrite_jaraco_text(pkg_files, new_root):
    """
    Rewrite imports in jaraco.text to redirect to vendored copies.
    """
    for file in pkg_files.glob('*.py'):
        text = file.read_text()
        text = re.sub(r' (jaraco\.)', rf' {new_root}.\1', text)
        text = re.sub(r' (importlib_resources)', rf' {new_root}.\1', text)
        # suppress loading of lorem_ipsum; ref #3072
        text = re.sub(r'^lorem_ipsum.*\n$', '', text, flags=re.M)
        file.write_text(text)


def rewrite_jaraco(pkg_files, new_root):
    """
    Rewrite imports in jaraco.functools to redirect to vendored copies.
    """
    for file in pkg_files.glob('*.py'):
        text = file.read_text()
        text = re.sub(r' (more_itertools)', rf' {new_root}.\1', text)
        file.write_text(text)
    # required for zip-packaged setuptools #3084
    pkg_files.joinpath('__init__.py').write_text('')


def rewrite_importlib_resources(pkg_files, new_root):
    """
    Rewrite imports in importlib_resources to redirect to vendored copies.
    """
    for file in pkg_files.glob('*.py'):
        text = file.read_text().replace('importlib_resources.abc', '.abc')
        text = text.replace('zipp', '..zipp')
        file.write_text(text)


def rewrite_importlib_metadata(pkg_files, new_root):
    """
    Rewrite imports in importlib_metadata to redirect to vendored copies.
    """
    for file in pkg_files.glob('*.py'):
        text = file.read_text().replace('typing_extensions', '..typing_extensions')
        text = text.replace('import zipp', 'from .. import zipp')
        file.write_text(text)


def rewrite_more_itertools(pkg_files: Path):
    """
    Defer import of concurrent.futures. Workaround for #3090.
    """
    more_file = pkg_files.joinpath('more.py')
    text = more_file.read_text()
    text = re.sub(r'^.*concurrent.futures.*?\n', '', text, flags=re.MULTILINE)
    text = re.sub(
        'ThreadPoolExecutor',
        '__import__("concurrent.futures").futures.ThreadPoolExecutor',
        text,
    )
    more_file.write_text(text)


def rewrite_platformdirs(pkg_files: Path):
    """
    Replace some absolute imports with relative ones.
    """
    init = pkg_files.joinpath('__init__.py')
    text = init.read_text()
    text = text.replace('from platformdirs.', 'from .')
    text = text.replace('from typing_extensions', 'from ..typing_extensions')
    init.write_text(text)


def clean(vendor):
    """
    Remove all files out of the vendor directory except the meta
    data (as pip uninstall doesn't support -t).
    """
    remove_all(path for path in vendor.glob('*') if path.basename() != 'vendored.txt')


def install(vendor):
    clean(vendor)
    install_args = [
        sys.executable,
        '-m',
        'pip',
        'install',
        '-r',
        str(vendor / 'vendored.txt'),
        '-t',
        str(vendor),
    ]
    subprocess.check_call(install_args)
    (vendor / '__init__.py').write_text('')


def update_pkg_resources():
    vendor = Path('pkg_resources/_vendor')
    install(vendor)
    rewrite_packaging(vendor / 'packaging', 'pkg_resources.extern')
    rewrite_jaraco_text(vendor / 'jaraco/text', 'pkg_resources.extern')
    rewrite_jaraco(vendor / 'jaraco', 'pkg_resources.extern')
    rewrite_importlib_resources(vendor / 'importlib_resources', 'pkg_resources.extern')
    rewrite_more_itertools(vendor / "more_itertools")
    rewrite_platformdirs(vendor / "platformdirs")


def update_setuptools():
    vendor = Path('setuptools/_vendor')
    install(vendor)
    rewrite_packaging(vendor / 'packaging', 'setuptools.extern')
    rewrite_jaraco_text(vendor / 'jaraco/text', 'setuptools.extern')
    rewrite_jaraco(vendor / 'jaraco', 'setuptools.extern')
    rewrite_importlib_resources(vendor / 'importlib_resources', 'setuptools.extern')
    rewrite_importlib_metadata(vendor / 'importlib_metadata', 'setuptools.extern')
    rewrite_more_itertools(vendor / "more_itertools")


__name__ == '__main__' and update_vendored()
././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1692360458.0
setuptools-68.1.2/tox.ini0000644000175100001730000000376114467657412014774 0ustar00runnerdocker[testenv]
deps =
	# Ideally all the dependencies should be set as "extras"
	# workaround for pypa/build#630
	build[virtualenv] @ git+https://github.com/jaraco/build@bugfix/630-importlib-metadata
setenv =
	PYTHONWARNDEFAULTENCODING = 1
	SETUPTOOLS_ENFORCE_DEPRECATION = 1
commands =
	pytest {posargs}
usedevelop = True
extras =
	testing
passenv =
	SETUPTOOLS_USE_DISTUTILS
	PRE_BUILT_SETUPTOOLS_WHEEL
	PRE_BUILT_SETUPTOOLS_SDIST
	TIMEOUT_BACKEND_TEST  # timeout (in seconds) for test_build_meta
	windir  # required for test_pkg_resources
	# honor git config in pytest-perf
	HOME

[testenv:integration]
deps = {[testenv]deps}
extras = testing-integration
passenv =
	{[testenv]passenv}
	DOWNLOAD_PATH
setenv =
    PROJECT_ROOT = {toxinidir}
commands =
	pytest --integration {posargs:-vv --durations=10} setuptools/tests/integration
	# use verbose mode by default to facilitate debugging from CI logs

[testenv:docs]
extras =
	docs
	testing
changedir = docs
deps =
	importlib_resources < 6  # twisted/towncrier#528 (waiting for release)
commands =
	python -m sphinx -W --keep-going . {toxinidir}/build/html
	python -m sphinxlint

[testenv:finalize]
skip_install = True
deps =
	towncrier
	bump2version
	jaraco.develop >= 7.23
	importlib_resources < 6  # twisted/towncrier#528 (waiting for release)
passenv = *
commands =
	python tools/finalize.py

[testenv:vendor]
skip_install = True
deps =
	path
commands =
	python -m tools.vendored

[testenv:generate-validation-code]
skip_install = True
deps =
	validate-pyproject[all]==0.12.2
commands =
	python -m tools.generate_validation_code

[testenv:release]
skip_install = True
deps =
	build
	twine>=3
	jaraco.develop>=7.1
passenv =
	TWINE_PASSWORD
	GITHUB_TOKEN
setenv =
	TWINE_USERNAME = {env:TWINE_USERNAME:__token__}
commands =
	python -c "import shutil; shutil.rmtree('dist', ignore_errors=True)"
	# unset tag_build and tag_date pypa/setuptools#2500
	python setup.py egg_info -Db "" saveopts
	python -m build
	python -m twine upload dist/*
	python -m jaraco.develop.create-github-release