- rev: v2.3.0

- rev: v0.790

- - id: mypy

- name: mypy for Python 2

- exclude: '^(docs|tasks|tests)|setup\.py|noxfile\.py'

- args: ["--py2"]

- rev: 19.3b0

- rev: 5.6.4

- rev: "3.7.8"

-* Run [isort](https://pypi.org/project/isort/) over the code base (:issue:`377`)

-* Expand upon the API provded by ``packaging.tags``: ``interpreter_name()``, ``mac_platforms()``, ``compatible_tags()``, ``cpython_tags()``, ``generic_tags()`` (:issue:`187`)

-* Fix an error where the arbitary specifier (``===``) was not correctly

-recursive-include tests hello-world-*

-exclude tests/build-hello-world.sh

-Version: 20.9

-Description: packaging

- =========

-

- .. start-intro

-

- Reusable core utilities for various Python Packaging

- `interoperability specifications <https://packaging.python.org/specifications/>`_.

-

- This library provides utilities that implement the interoperability

- specifications which have clearly one correct behaviour (eg: :pep:`440`)

- or benefit greatly from having a single shared implementation (eg: :pep:`425`).

-

- .. end-intro

-

- The ``packaging`` project includes the following: version handling, specifiers,

- markers, requirements, tags, utilities.

-

- Documentation

- -------------

-

- The `documentation`_ provides information and the API for the following:

-

- - Version Handling

- - Specifiers

- - Markers

- - Requirements

- - Tags

- - Utilities

-

- Installation

- ------------

-

- Use ``pip`` to install these utilities::

-

- pip install packaging

-

- Discussion

- ----------

-

- If you run into bugs, you can file them in our `issue tracker`_.

-

- You can also join ``#pypa`` on Freenode to ask questions or get involved.

-

-

- .. _`documentation`: https://packaging.pypa.io/

- .. _`issue tracker`: https://github.com/pypa/packaging/issues

-

-

- Code of Conduct

- ---------------

-

- Everyone interacting in the packaging project's codebases, issue trackers, chat

- rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.

-

- .. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md

-

- Contributing

- ------------

-

- The ``CONTRIBUTING.rst`` file outlines how to contribute to this project as

- well as how to report a potential security issue. The documentation for this

- project also covers information about `project development`_ and `security`_.

-

- .. _`project development`: https://packaging.pypa.io/en/latest/development/

- .. _`security`: https://packaging.pypa.io/en/latest/security/

-

- Project History

- ---------------

-

- Please review the ``CHANGELOG.rst`` file or the `Changelog documentation`_ for

- recent changes and project history.

-

- .. _`Changelog documentation`: https://packaging.pypa.io/en/latest/changelog/

-

- Changelog

- ---------

-

- 20.9 - 2021-01-29

- ~~~~~~~~~~~~~~~~~

-

- * Run [isort](https://pypi.org/project/isort/) over the code base (`#377 <https://github.com/pypa/packaging/issues/377>`__)

- * Add support for the ``macosx_10_*_universal2`` platform tags (`#379 <https://github.com/pypa/packaging/issues/379>`__)

- * Introduce ``packaging.utils.parse_wheel_filename()`` and ``parse_sdist_filename()``

- (`#387 <https://github.com/pypa/packaging/issues/387>`__ and `#389 <https://github.com/pypa/packaging/issues/389>`__)

-

- 20.8 - 2020-12-11

- ~~~~~~~~~~~~~~~~~

-

- * Revert back to setuptools for compatibility purposes for some Linux distros (`#363 <https://github.com/pypa/packaging/issues/363>`__)

- * Do not insert an underscore in wheel tags when the interpreter version number

- is more than 2 digits (`#372 <https://github.com/pypa/packaging/issues/372>`__)

-

- 20.7 - 2020-11-28

- ~~~~~~~~~~~~~~~~~

-

- No unreleased changes.

-

- 20.6 - 2020-11-28

- ~~~~~~~~~~~~~~~~~

-

- .. note:: This release was subsequently yanked, and these changes were included in 20.7.

-

- * Fix flit configuration, to include LICENSE files (`#357 <https://github.com/pypa/packaging/issues/357>`__)

- * Make `intel` a recognized CPU architecture for the `universal` macOS platform tag (`#361 <https://github.com/pypa/packaging/issues/361>`__)

- * Add some missing type hints to `packaging.requirements` (issue:`350`)

-

- 20.5 - 2020-11-27

- ~~~~~~~~~~~~~~~~~

-

- * Officially support Python 3.9 (`#343 <https://github.com/pypa/packaging/issues/343>`__)

- * Deprecate the ``LegacyVersion`` and ``LegacySpecifier`` classes (`#321 <https://github.com/pypa/packaging/issues/321>`__)

- * Handle ``OSError`` on non-dynamic executables when attempting to resolve

- the glibc version string.

-

- 20.4 - 2020-05-19

- ~~~~~~~~~~~~~~~~~

-

- * Canonicalize version before comparing specifiers. (`#282 <https://github.com/pypa/packaging/issues/282>`__)

- * Change type hint for ``canonicalize_name`` to return

- ``packaging.utils.NormalizedName``.

- This enables the use of static typing tools (like mypy) to detect mixing of

- normalized and un-normalized names.

-

- 20.3 - 2020-03-05

- ~~~~~~~~~~~~~~~~~

-

- * Fix changelog for 20.2.

-

- 20.2 - 2020-03-05

- ~~~~~~~~~~~~~~~~~

-

- * Fix a bug that caused a 32-bit OS that runs on a 64-bit ARM CPU (e.g. ARM-v8,

- aarch64), to report the wrong bitness.

-

- 20.1 - 2020-01-24

- ~~~~~~~~~~~~~~~~~~~

-

- * Fix a bug caused by reuse of an exhausted iterator. (`#257 <https://github.com/pypa/packaging/issues/257>`__)

-

- 20.0 - 2020-01-06

- ~~~~~~~~~~~~~~~~~

-

- * Add type hints (`#191 <https://github.com/pypa/packaging/issues/191>`__)

-

- * Add proper trove classifiers for PyPy support (`#198 <https://github.com/pypa/packaging/issues/198>`__)

-

- * Scale back depending on ``ctypes`` for manylinux support detection (`#171 <https://github.com/pypa/packaging/issues/171>`__)

-

- * Use ``sys.implementation.name`` where appropriate for ``packaging.tags`` (`#193 <https://github.com/pypa/packaging/issues/193>`__)

-

- * Expand upon the API provded by ``packaging.tags``: ``interpreter_name()``, ``mac_platforms()``, ``compatible_tags()``, ``cpython_tags()``, ``generic_tags()`` (`#187 <https://github.com/pypa/packaging/issues/187>`__)

-

- * Officially support Python 3.8 (`#232 <https://github.com/pypa/packaging/issues/232>`__)

-

- * Add ``major``, ``minor``, and ``micro`` aliases to ``packaging.version.Version`` (`#226 <https://github.com/pypa/packaging/issues/226>`__)

-

- * Properly mark ``packaging`` has being fully typed by adding a `py.typed` file (`#226 <https://github.com/pypa/packaging/issues/226>`__)

-

- 19.2 - 2019-09-18

- ~~~~~~~~~~~~~~~~~

-

- * Remove dependency on ``attrs`` (`#178 <https://github.com/pypa/packaging/issues/178>`__, `#179 <https://github.com/pypa/packaging/issues/179>`__)

-

- * Use appropriate fallbacks for CPython ABI tag (`#181 <https://github.com/pypa/packaging/issues/181>`__, `#185 <https://github.com/pypa/packaging/issues/185>`__)

-

- * Add manylinux2014 support (`#186 <https://github.com/pypa/packaging/issues/186>`__)

-

- * Improve ABI detection (`#181 <https://github.com/pypa/packaging/issues/181>`__)

-

- * Properly handle debug wheels for Python 3.8 (`#172 <https://github.com/pypa/packaging/issues/172>`__)

-

- * Improve detection of debug builds on Windows (`#194 <https://github.com/pypa/packaging/issues/194>`__)

-

- 19.1 - 2019-07-30

- ~~~~~~~~~~~~~~~~~

-

- * Add the ``packaging.tags`` module. (`#156 <https://github.com/pypa/packaging/issues/156>`__)

-

- * Correctly handle two-digit versions in ``python_version`` (`#119 <https://github.com/pypa/packaging/issues/119>`__)

-

-

- 19.0 - 2019-01-20

- ~~~~~~~~~~~~~~~~~

-

- * Fix string representation of PEP 508 direct URL requirements with markers.

-

- * Better handling of file URLs

-

- This allows for using ``file:///absolute/path``, which was previously

- prevented due to the missing ``netloc``.

-

- This allows for all file URLs that ``urlunparse`` turns back into the

- original URL to be valid.

-

-

- 18.0 - 2018-09-26

- ~~~~~~~~~~~~~~~~~

-

- * Improve error messages when invalid requirements are given. (`#129 <https://github.com/pypa/packaging/issues/129>`__)

-

-

- 17.1 - 2017-02-28

- ~~~~~~~~~~~~~~~~~

-

- * Fix ``utils.canonicalize_version`` when supplying non PEP 440 versions.

-

-

- 17.0 - 2017-02-28

- ~~~~~~~~~~~~~~~~~

-

- * Drop support for python 2.6, 3.2, and 3.3.

-

- * Define minimal pyparsing version to 2.0.2 (`#91 <https://github.com/pypa/packaging/issues/91>`__).

-

- * Add ``epoch``, ``release``, ``pre``, ``dev``, and ``post`` attributes to

- ``Version`` and ``LegacyVersion`` (`#34 <https://github.com/pypa/packaging/issues/34>`__).

-

- * Add ``Version().is_devrelease`` and ``LegacyVersion().is_devrelease`` to

- make it easy to determine if a release is a development release.

-

- * Add ``utils.canonicalize_version`` to canonicalize version strings or

- ``Version`` instances (`#121 <https://github.com/pypa/packaging/issues/121>`__).

-

-

- 16.8 - 2016-10-29

- ~~~~~~~~~~~~~~~~~

-

- * Fix markers that utilize ``in`` so that they render correctly.

-

- * Fix an erroneous test on Python RC releases.

-

-

- 16.7 - 2016-04-23

- ~~~~~~~~~~~~~~~~~

-

- * Add support for the deprecated ``python_implementation`` marker which was

- an undocumented setuptools marker in addition to the newer markers.

-

-

- 16.6 - 2016-03-29

- ~~~~~~~~~~~~~~~~~

-

- * Add support for the deprecated, PEP 345 environment markers in addition to

- the newer markers.

-

-

- 16.5 - 2016-02-26

- ~~~~~~~~~~~~~~~~~

-

- * Fix a regression in parsing requirements with whitespaces between the comma

- separators.

-

-

- 16.4 - 2016-02-22

- ~~~~~~~~~~~~~~~~~

-

- * Fix a regression in parsing requirements like ``foo (==4)``.

-

-

- 16.3 - 2016-02-21

- ~~~~~~~~~~~~~~~~~

-

- * Fix a bug where ``packaging.requirements:Requirement`` was overly strict when

- matching legacy requirements.

-

-

- 16.2 - 2016-02-09

- ~~~~~~~~~~~~~~~~~

-

- * Add a function that implements the name canonicalization from PEP 503.

-

-

- 16.1 - 2016-02-07

- ~~~~~~~~~~~~~~~~~

-

- * Implement requirement specifiers from PEP 508.

-

-

- 16.0 - 2016-01-19

- ~~~~~~~~~~~~~~~~~

-

- * Relicense so that packaging is available under *either* the Apache License,

- Version 2.0 or a 2 Clause BSD license.

-

- * Support installation of packaging when only distutils is available.

-

- * Fix ``==`` comparison when there is a prefix and a local version in play.

- (`#41 <https://github.com/pypa/packaging/issues/41>`__).

-

- * Implement environment markers from PEP 508.

-

-

- 15.3 - 2015-08-01

- ~~~~~~~~~~~~~~~~~

-

- * Normalize post-release spellings for rev/r prefixes. `#35 <https://github.com/pypa/packaging/issues/35>`__

-

-

- 15.2 - 2015-05-13

- ~~~~~~~~~~~~~~~~~

-

- * Fix an error where the arbitary specifier (``===``) was not correctly

- allowing pre-releases when it was being used.

-

- * Expose the specifier and version parts through properties on the

- ``Specifier`` classes.

-

- * Allow iterating over the ``SpecifierSet`` to get access to all of the

- ``Specifier`` instances.

-

- * Allow testing if a version is contained within a specifier via the ``in``

- operator.

-

-

- 15.1 - 2015-04-13

- ~~~~~~~~~~~~~~~~~

-

- * Fix a logic error that was causing inconsistent answers about whether or not

- a pre-release was contained within a ``SpecifierSet`` or not.

-

-

- 15.0 - 2015-01-02

- ~~~~~~~~~~~~~~~~~

-

- * Add ``Version().is_postrelease`` and ``LegacyVersion().is_postrelease`` to

- make it easy to determine if a release is a post release.

-

- * Add ``Version().base_version`` and ``LegacyVersion().base_version`` to make

- it easy to get the public version without any pre or post release markers.

-

- * Support the update to PEP 440 which removed the implied ``!=V.*`` when using

- either ``>V`` or ``<V`` and which instead special cased the handling of

- pre-releases, post-releases, and local versions when using ``>V`` or ``<V``.

-

-

- 14.5 - 2014-12-17

- ~~~~~~~~~~~~~~~~~

-

- * Normalize release candidates as ``rc`` instead of ``c``.

-

- * Expose the ``VERSION_PATTERN`` constant, a regular expression matching

- a valid version.

-

-

- 14.4 - 2014-12-15

- ~~~~~~~~~~~~~~~~~

-

- * Ensure that versions are normalized before comparison when used in a

- specifier with a less than (``<``) or greater than (``>``) operator.

-

-

- 14.3 - 2014-11-19

- ~~~~~~~~~~~~~~~~~

-

- * **BACKWARDS INCOMPATIBLE** Refactor specifier support so that it can sanely

- handle legacy specifiers as well as PEP 440 specifiers.

-

- * **BACKWARDS INCOMPATIBLE** Move the specifier support out of

- ``packaging.version`` into ``packaging.specifiers``.

-

-

- 14.2 - 2014-09-10

- ~~~~~~~~~~~~~~~~~

-

- * Add prerelease support to ``Specifier``.

- * Remove the ability to do ``item in Specifier()`` and replace it with

- ``Specifier().contains(item)`` in order to allow flags that signal if a

- prerelease should be accepted or not.

- * Add a method ``Specifier().filter()`` which will take an iterable and returns

- an iterable with items that do not match the specifier filtered out.

-

-

- 14.1 - 2014-09-08

- ~~~~~~~~~~~~~~~~~

-

- * Allow ``LegacyVersion`` and ``Version`` to be sorted together.

- * Add ``packaging.version.parse()`` to enable easily parsing a version string

- as either a ``Version`` or a ``LegacyVersion`` depending on it's PEP 440

- validity.

-

-

- 14.0 - 2014-09-05

- ~~~~~~~~~~~~~~~~~

-

- * Initial release.

-

-

- .. _`master`: https://github.com/pypa/packaging/

-

-Classifier: Programming Language :: Python :: 2

-Classifier: Programming Language :: Python :: 2.7

-Classifier: Programming Language :: Python :: 3.4

-Classifier: Programming Language :: Python :: 3.5

-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*

-Standards-Version: 4.5.1

---- a/packaging/tags.py

-+++ b/packaging/tags.py

-@@ -4,8 +4,6 @@

-

- from __future__ import absolute_import

-

--import distutils.util

--

- try:

- from importlib.machinery import EXTENSION_SUFFIXES

- except ImportError: # pragma: no cover

-@@ -781,7 +779,7 @@ def _manylinux_tags(linux, arch):

-

- def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):

- # type: (bool) -> Iterator[str]

-- linux = _normalize_string(distutils.util.get_platform())

-+ linux = _normalize_string(sysconfig.get_platform())

- if is_32bit:

- if linux == "linux_x86_64":

- linux = "linux_i686"

-@@ -796,7 +794,7 @@ def _linux_platforms(is_32bit=_32_BIT_IN

-

- def _generic_platforms():

- # type: () -> Iterator[str]

-- yield _normalize_string(distutils.util.get_platform())

-+ yield _normalize_string(sysconfig.get_platform())

-

-

- def _platform_tags():

---- a/tests/test_tags.py

-+++ b/tests/test_tags.py

-@@ -11,7 +11,6 @@ try:

- import ctypes

- except ImportError:

- ctypes = None

--import distutils.util

- import os

- import platform

- import re

-@@ -492,14 +491,14 @@ class TestManylinuxPlatform:

- def test_linux_platforms_32_64bit_on_64bit_os(

- self, arch, is_32bit, expected, monkeypatch

- ):

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: arch)

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: arch)

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda *args: False)

- linux_platform = list(tags._linux_platforms(is_32bit=is_32bit))[-1]

- assert linux_platform == expected

-

- def test_linux_platforms_manylinux_unsupported(self, monkeypatch):

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda *args: False)

- linux_platform = list(tags._linux_platforms(is_32bit=False))

-@@ -509,7 +508,7 @@ class TestManylinuxPlatform:

- monkeypatch.setattr(

- tags, "_is_manylinux_compatible", lambda name, *args: name == "manylinux1"

- )

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(platform, "machine", lambda: "x86_64")

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)

- platforms = list(tags._linux_platforms(is_32bit=False))

-@@ -517,7 +516,7 @@ class TestManylinuxPlatform:

- assert platforms == ["manylinux1_" + arch, "linux_" + arch]

-

- def test_linux_platforms_manylinux2010(self, monkeypatch):

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(platform, "machine", lambda: "x86_64")

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.12", raising=False)

- platforms = list(tags._linux_platforms(is_32bit=False))

-@@ -538,7 +537,7 @@ class TestManylinuxPlatform:

- assert platforms == expected

-

- def test_linux_platforms_manylinux2014(self, monkeypatch):

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(platform, "machine", lambda: "x86_64")

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.17", raising=False)

- platforms = list(tags._linux_platforms(is_32bit=False))

-@@ -571,7 +570,7 @@ class TestManylinuxPlatform:

- "_is_manylinux_compatible",

- lambda name, *args: name == "manylinux2014",

- )

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_armv7l")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_armv7l")

- monkeypatch.setattr(

- sys,

- "executable",

-@@ -583,7 +582,7 @@ class TestManylinuxPlatform:

-

- def test_linux_platforms_manylinux2014_i386_abi(self, monkeypatch):

- monkeypatch.setattr(tags, "_glibc_version_string", lambda: "2.17")

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(

- sys,

- "executable",

-@@ -615,7 +614,7 @@ class TestManylinuxPlatform:

- # test for a future glic 3.x version

- monkeypatch.setattr(tags, "_glibc_version_string", lambda: "3.2")

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda name, *args: True)

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_aarch64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_aarch64")

- monkeypatch.setattr(

- sys,

- "executable",

-@@ -633,7 +632,7 @@ class TestManylinuxPlatform:

- monkeypatch.setattr(

- tags, "_is_manylinux_compatible", lambda name, _: name == "manylinux2014"

- )

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_armv6l")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_armv6l")

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)

- platforms = list(tags._linux_platforms(is_32bit=True))

- expected = ["linux_armv6l"]

-@@ -648,7 +647,7 @@ class TestManylinuxPlatform:

- ):

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda name, _: False)

- monkeypatch.setattr(

-- distutils.util, "get_platform", lambda: "linux_{}".format(machine)

-+ sysconfig, "get_platform", lambda: "linux_{}".format(machine)

- )

- monkeypatch.setattr(

- sys,

-@@ -995,7 +994,7 @@ class TestGenericTags:

- assert not list(tags._generic_abi())

-

- def test_generic_platforms(self):

-- platform = distutils.util.get_platform().replace("-", "_")

-+ platform = sysconfig.get_platform().replace("-", "_")

- platform = platform.replace(".", "_")

- assert list(tags._generic_platforms()) == [platform]

-

-@@ -1269,14 +1268,14 @@ class TestSysTags:

- assert result[-1] == expected

-

- def test_linux_platforms_manylinux2014_armv6l(self, monkeypatch, manylinux_module):

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_armv6l")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_armv6l")

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)

- platforms = list(tags._linux_platforms(is_32bit=True))

- expected = ["linux_armv6l"]

- assert platforms == expected

-

- def test_skip_manylinux_2014(self, monkeypatch, manylinux_module):

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_ppc64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_ppc64")

- monkeypatch.setattr(tags, "_get_glibc_version", lambda: (2, 20))

- monkeypatch.setattr(

- manylinux_module, "manylinux2014_compatible", False, raising=False

-@@ -1300,7 +1299,7 @@ class TestSysTags:

- self, monkeypatch, manylinux_module, machine, abi, alt_machine

- ):

- monkeypatch.setattr(

-- distutils.util, "get_platform", lambda: "linux_{}".format(machine)

-+ sysconfig, "get_platform", lambda: "linux_{}".format(machine)

- )

- monkeypatch.setattr(

- sys,

-@@ -1326,7 +1325,7 @@ class TestSysTags:

-

- monkeypatch.setattr(tags, "_get_glibc_version", lambda: (major, minor))

- monkeypatch.setattr(

-- distutils.util, "get_platform", lambda: "linux_{}".format(machine)

-+ sysconfig, "get_platform", lambda: "linux_{}".format(machine)

- )

- monkeypatch.setattr(

- manylinux_module,

-@@ -1349,7 +1348,7 @@ class TestSysTags:

- return None

-

- monkeypatch.setattr(tags, "_get_glibc_version", lambda: (2, 30))

-- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

-+ monkeypatch.setattr(sysconfig, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(

- manylinux_module,

- "manylinux_compatible",

-get_platform.diff

-# -*- coding: utf-8 -*-

-from __future__ import absolute_import, division, print_function

- nox > * tests-2.7: success

- nox > * tests-3.4: skipped

- nox > * tests-3.5: success

- nox > * tests-pypy: skipped

-Additionally, every Python code file must contain

-

-.. code-block:: python

-

- from __future__ import absolute_import, division, print_function

-

-

-.. class:: SpecifierSet(specifiers, prereleases=None)

-#

-# Note: warn_unused_ignores is False due to incorrect typeshed annotations for

-# platform.mac_ver()

-warn_unused_ignores = False

-Version: 20.9

-Description: packaging

- =========

-

- .. start-intro

-

- Reusable core utilities for various Python Packaging

- `interoperability specifications <https://packaging.python.org/specifications/>`_.

-

- This library provides utilities that implement the interoperability

- specifications which have clearly one correct behaviour (eg: :pep:`440`)

- or benefit greatly from having a single shared implementation (eg: :pep:`425`).

-

- .. end-intro

-

- The ``packaging`` project includes the following: version handling, specifiers,

- markers, requirements, tags, utilities.

-

- Documentation

- -------------

-

- The `documentation`_ provides information and the API for the following:

-

- - Version Handling

- - Specifiers

- - Markers

- - Requirements

- - Tags

- - Utilities

-

- Installation

- ------------

-

- Use ``pip`` to install these utilities::

-

- pip install packaging

-

- Discussion

- ----------

-

- If you run into bugs, you can file them in our `issue tracker`_.

-

- You can also join ``#pypa`` on Freenode to ask questions or get involved.

-

-

- .. _`documentation`: https://packaging.pypa.io/

- .. _`issue tracker`: https://github.com/pypa/packaging/issues

-

-

- Code of Conduct

- ---------------

-

- Everyone interacting in the packaging project's codebases, issue trackers, chat

- rooms, and mailing lists is expected to follow the `PSF Code of Conduct`_.

-

- .. _PSF Code of Conduct: https://github.com/pypa/.github/blob/main/CODE_OF_CONDUCT.md

-

- Contributing

- ------------

-

- The ``CONTRIBUTING.rst`` file outlines how to contribute to this project as

- well as how to report a potential security issue. The documentation for this

- project also covers information about `project development`_ and `security`_.

-

- .. _`project development`: https://packaging.pypa.io/en/latest/development/

- .. _`security`: https://packaging.pypa.io/en/latest/security/

-

- Project History

- ---------------

-

- Please review the ``CHANGELOG.rst`` file or the `Changelog documentation`_ for

- recent changes and project history.

-

- .. _`Changelog documentation`: https://packaging.pypa.io/en/latest/changelog/

-

- Changelog

- ---------

-

- 20.9 - 2021-01-29

- ~~~~~~~~~~~~~~~~~

-

- * Run [isort](https://pypi.org/project/isort/) over the code base (`#377 <https://github.com/pypa/packaging/issues/377>`__)

- * Add support for the ``macosx_10_*_universal2`` platform tags (`#379 <https://github.com/pypa/packaging/issues/379>`__)

- * Introduce ``packaging.utils.parse_wheel_filename()`` and ``parse_sdist_filename()``

- (`#387 <https://github.com/pypa/packaging/issues/387>`__ and `#389 <https://github.com/pypa/packaging/issues/389>`__)

-

- 20.8 - 2020-12-11

- ~~~~~~~~~~~~~~~~~

-

- * Revert back to setuptools for compatibility purposes for some Linux distros (`#363 <https://github.com/pypa/packaging/issues/363>`__)

- * Do not insert an underscore in wheel tags when the interpreter version number

- is more than 2 digits (`#372 <https://github.com/pypa/packaging/issues/372>`__)

-

- 20.7 - 2020-11-28

- ~~~~~~~~~~~~~~~~~

-

- No unreleased changes.

-

- 20.6 - 2020-11-28

- ~~~~~~~~~~~~~~~~~

-

- .. note:: This release was subsequently yanked, and these changes were included in 20.7.

-

- * Fix flit configuration, to include LICENSE files (`#357 <https://github.com/pypa/packaging/issues/357>`__)

- * Make `intel` a recognized CPU architecture for the `universal` macOS platform tag (`#361 <https://github.com/pypa/packaging/issues/361>`__)

- * Add some missing type hints to `packaging.requirements` (issue:`350`)

-

- 20.5 - 2020-11-27

- ~~~~~~~~~~~~~~~~~

-

- * Officially support Python 3.9 (`#343 <https://github.com/pypa/packaging/issues/343>`__)

- * Deprecate the ``LegacyVersion`` and ``LegacySpecifier`` classes (`#321 <https://github.com/pypa/packaging/issues/321>`__)

- * Handle ``OSError`` on non-dynamic executables when attempting to resolve

- the glibc version string.

-

- 20.4 - 2020-05-19

- ~~~~~~~~~~~~~~~~~

-

- * Canonicalize version before comparing specifiers. (`#282 <https://github.com/pypa/packaging/issues/282>`__)

- * Change type hint for ``canonicalize_name`` to return

- ``packaging.utils.NormalizedName``.

- This enables the use of static typing tools (like mypy) to detect mixing of

- normalized and un-normalized names.

-

- 20.3 - 2020-03-05

- ~~~~~~~~~~~~~~~~~

-

- * Fix changelog for 20.2.

-

- 20.2 - 2020-03-05

- ~~~~~~~~~~~~~~~~~

-

- * Fix a bug that caused a 32-bit OS that runs on a 64-bit ARM CPU (e.g. ARM-v8,

- aarch64), to report the wrong bitness.

-

- 20.1 - 2020-01-24

- ~~~~~~~~~~~~~~~~~~~

-

- * Fix a bug caused by reuse of an exhausted iterator. (`#257 <https://github.com/pypa/packaging/issues/257>`__)

-

- 20.0 - 2020-01-06

- ~~~~~~~~~~~~~~~~~

-

- * Add type hints (`#191 <https://github.com/pypa/packaging/issues/191>`__)

-

- * Add proper trove classifiers for PyPy support (`#198 <https://github.com/pypa/packaging/issues/198>`__)

-

- * Scale back depending on ``ctypes`` for manylinux support detection (`#171 <https://github.com/pypa/packaging/issues/171>`__)

-

- * Use ``sys.implementation.name`` where appropriate for ``packaging.tags`` (`#193 <https://github.com/pypa/packaging/issues/193>`__)

-

- * Expand upon the API provded by ``packaging.tags``: ``interpreter_name()``, ``mac_platforms()``, ``compatible_tags()``, ``cpython_tags()``, ``generic_tags()`` (`#187 <https://github.com/pypa/packaging/issues/187>`__)

-

- * Officially support Python 3.8 (`#232 <https://github.com/pypa/packaging/issues/232>`__)

-

- * Add ``major``, ``minor``, and ``micro`` aliases to ``packaging.version.Version`` (`#226 <https://github.com/pypa/packaging/issues/226>`__)

-

- * Properly mark ``packaging`` has being fully typed by adding a `py.typed` file (`#226 <https://github.com/pypa/packaging/issues/226>`__)

-

- 19.2 - 2019-09-18

- ~~~~~~~~~~~~~~~~~

-

- * Remove dependency on ``attrs`` (`#178 <https://github.com/pypa/packaging/issues/178>`__, `#179 <https://github.com/pypa/packaging/issues/179>`__)

-

- * Use appropriate fallbacks for CPython ABI tag (`#181 <https://github.com/pypa/packaging/issues/181>`__, `#185 <https://github.com/pypa/packaging/issues/185>`__)

-

- * Add manylinux2014 support (`#186 <https://github.com/pypa/packaging/issues/186>`__)

-

- * Improve ABI detection (`#181 <https://github.com/pypa/packaging/issues/181>`__)

-

- * Properly handle debug wheels for Python 3.8 (`#172 <https://github.com/pypa/packaging/issues/172>`__)

-

- * Improve detection of debug builds on Windows (`#194 <https://github.com/pypa/packaging/issues/194>`__)

-

- 19.1 - 2019-07-30

- ~~~~~~~~~~~~~~~~~

-

- * Add the ``packaging.tags`` module. (`#156 <https://github.com/pypa/packaging/issues/156>`__)

-

- * Correctly handle two-digit versions in ``python_version`` (`#119 <https://github.com/pypa/packaging/issues/119>`__)

-

-

- 19.0 - 2019-01-20

- ~~~~~~~~~~~~~~~~~

-

- * Fix string representation of PEP 508 direct URL requirements with markers.

-

- * Better handling of file URLs

-

- This allows for using ``file:///absolute/path``, which was previously

- prevented due to the missing ``netloc``.

-

- This allows for all file URLs that ``urlunparse`` turns back into the

- original URL to be valid.

-

-

- 18.0 - 2018-09-26

- ~~~~~~~~~~~~~~~~~

-

- * Improve error messages when invalid requirements are given. (`#129 <https://github.com/pypa/packaging/issues/129>`__)

-

-

- 17.1 - 2017-02-28

- ~~~~~~~~~~~~~~~~~

-

- * Fix ``utils.canonicalize_version`` when supplying non PEP 440 versions.

-

-

- 17.0 - 2017-02-28

- ~~~~~~~~~~~~~~~~~

-

- * Drop support for python 2.6, 3.2, and 3.3.

-

- * Define minimal pyparsing version to 2.0.2 (`#91 <https://github.com/pypa/packaging/issues/91>`__).

-

- * Add ``epoch``, ``release``, ``pre``, ``dev``, and ``post`` attributes to

- ``Version`` and ``LegacyVersion`` (`#34 <https://github.com/pypa/packaging/issues/34>`__).

-

- * Add ``Version().is_devrelease`` and ``LegacyVersion().is_devrelease`` to

- make it easy to determine if a release is a development release.

-

- * Add ``utils.canonicalize_version`` to canonicalize version strings or

- ``Version`` instances (`#121 <https://github.com/pypa/packaging/issues/121>`__).

-

-

- 16.8 - 2016-10-29

- ~~~~~~~~~~~~~~~~~

-

- * Fix markers that utilize ``in`` so that they render correctly.

-

- * Fix an erroneous test on Python RC releases.

-

-

- 16.7 - 2016-04-23

- ~~~~~~~~~~~~~~~~~

-

- * Add support for the deprecated ``python_implementation`` marker which was

- an undocumented setuptools marker in addition to the newer markers.

-

-

- 16.6 - 2016-03-29

- ~~~~~~~~~~~~~~~~~

-

- * Add support for the deprecated, PEP 345 environment markers in addition to

- the newer markers.

-

-

- 16.5 - 2016-02-26

- ~~~~~~~~~~~~~~~~~

-

- * Fix a regression in parsing requirements with whitespaces between the comma

- separators.

-

-

- 16.4 - 2016-02-22

- ~~~~~~~~~~~~~~~~~

-

- * Fix a regression in parsing requirements like ``foo (==4)``.

-

-

- 16.3 - 2016-02-21

- ~~~~~~~~~~~~~~~~~

-

- * Fix a bug where ``packaging.requirements:Requirement`` was overly strict when

- matching legacy requirements.

-

-

- 16.2 - 2016-02-09

- ~~~~~~~~~~~~~~~~~

-

- * Add a function that implements the name canonicalization from PEP 503.

-

-

- 16.1 - 2016-02-07

- ~~~~~~~~~~~~~~~~~

-

- * Implement requirement specifiers from PEP 508.

-

-

- 16.0 - 2016-01-19

- ~~~~~~~~~~~~~~~~~

-

- * Relicense so that packaging is available under *either* the Apache License,

- Version 2.0 or a 2 Clause BSD license.

-

- * Support installation of packaging when only distutils is available.

-

- * Fix ``==`` comparison when there is a prefix and a local version in play.

- (`#41 <https://github.com/pypa/packaging/issues/41>`__).

-

- * Implement environment markers from PEP 508.

-

-

- 15.3 - 2015-08-01

- ~~~~~~~~~~~~~~~~~

-

- * Normalize post-release spellings for rev/r prefixes. `#35 <https://github.com/pypa/packaging/issues/35>`__

-

-

- 15.2 - 2015-05-13

- ~~~~~~~~~~~~~~~~~

-

- * Fix an error where the arbitary specifier (``===``) was not correctly

- allowing pre-releases when it was being used.

-

- * Expose the specifier and version parts through properties on the

- ``Specifier`` classes.

-

- * Allow iterating over the ``SpecifierSet`` to get access to all of the

- ``Specifier`` instances.

-

- * Allow testing if a version is contained within a specifier via the ``in``

- operator.

-

-

- 15.1 - 2015-04-13

- ~~~~~~~~~~~~~~~~~

-

- * Fix a logic error that was causing inconsistent answers about whether or not

- a pre-release was contained within a ``SpecifierSet`` or not.

-

-

- 15.0 - 2015-01-02

- ~~~~~~~~~~~~~~~~~

-

- * Add ``Version().is_postrelease`` and ``LegacyVersion().is_postrelease`` to

- make it easy to determine if a release is a post release.

-

- * Add ``Version().base_version`` and ``LegacyVersion().base_version`` to make

- it easy to get the public version without any pre or post release markers.

-

- * Support the update to PEP 440 which removed the implied ``!=V.*`` when using

- either ``>V`` or ``<V`` and which instead special cased the handling of

- pre-releases, post-releases, and local versions when using ``>V`` or ``<V``.

-

-

- 14.5 - 2014-12-17

- ~~~~~~~~~~~~~~~~~

-

- * Normalize release candidates as ``rc`` instead of ``c``.

-

- * Expose the ``VERSION_PATTERN`` constant, a regular expression matching

- a valid version.

-

-

- 14.4 - 2014-12-15

- ~~~~~~~~~~~~~~~~~

-

- * Ensure that versions are normalized before comparison when used in a

- specifier with a less than (``<``) or greater than (``>``) operator.

-

-

- 14.3 - 2014-11-19

- ~~~~~~~~~~~~~~~~~

-

- * **BACKWARDS INCOMPATIBLE** Refactor specifier support so that it can sanely

- handle legacy specifiers as well as PEP 440 specifiers.

-

- * **BACKWARDS INCOMPATIBLE** Move the specifier support out of

- ``packaging.version`` into ``packaging.specifiers``.

-

-

- 14.2 - 2014-09-10

- ~~~~~~~~~~~~~~~~~

-

- * Add prerelease support to ``Specifier``.

- * Remove the ability to do ``item in Specifier()`` and replace it with

- ``Specifier().contains(item)`` in order to allow flags that signal if a

- prerelease should be accepted or not.

- * Add a method ``Specifier().filter()`` which will take an iterable and returns

- an iterable with items that do not match the specifier filtered out.

-

-

- 14.1 - 2014-09-08

- ~~~~~~~~~~~~~~~~~

-

- * Allow ``LegacyVersion`` and ``Version`` to be sorted together.

- * Add ``packaging.version.parse()`` to enable easily parsing a version string

- as either a ``Version`` or a ``LegacyVersion`` depending on it's PEP 440

- validity.

-

-

- 14.0 - 2014-09-05

- ~~~~~~~~~~~~~~~~~

-

- * Initial release.

-

-

- .. _`master`: https://github.com/pypa/packaging/

-

-Classifier: Programming Language :: Python :: 2

-Classifier: Programming Language :: Python :: 2.7

-Classifier: Programming Language :: Python :: 3.4

-Classifier: Programming Language :: Python :: 3.5

-Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*

-packaging/_compat.py

-packaging/_typing.py

-tests/hello-world-armv7l-armel

-tests/hello-world-armv7l-armhf

-tests/hello-world-invalid-class

-tests/hello-world-invalid-data

-tests/hello-world-invalid-magic

-tests/hello-world-s390x-s390x

-tests/hello-world-too-short

-tests/hello-world-x86_64-amd64

-tests/hello-world-x86_64-i386

-tests/hello-world-x86_64-x32

-tests/test_version.py \ No newline at end of file

-from __future__ import absolute_import, division, print_function

-__version__ = "20.9"

-from __future__ import absolute_import, division, print_function

-# 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.

-from __future__ import absolute_import, division, print_function

-

-import sys

-

-from ._typing import TYPE_CHECKING

-

-if TYPE_CHECKING: # pragma: no cover

- from typing import Any, Dict, Tuple, Type

-

-

-PY2 = sys.version_info[0] == 2

-PY3 = sys.version_info[0] == 3

-

-# flake8: noqa

-

-if PY3:

- string_types = (str,)

-else:

- string_types = (basestring,)

-

-

-def with_metaclass(meta, *bases):

- # type: (Type[Any], Tuple[Type[Any], ...]) -> Any

- """

- Create a base class with a metaclass.

- """

- # This requires a bit of explanation: the basic idea is to make a dummy

- # metaclass for one level of class instantiation that replaces itself with

- # the actual metaclass.

- class metaclass(meta): # type: ignore

- def __new__(cls, name, this_bases, d):

- # type: (Type[Any], str, Tuple[Any], Dict[Any, Any]) -> Any

- return meta(name, bases, d)

-

- return type.__new__(metaclass, "temporary_class", (), {})

-from __future__ import absolute_import, division, print_function

-class InfinityType(object):

- def __repr__(self):

- # type: () -> str

- def __hash__(self):

- # type: () -> int

- def __lt__(self, other):

- # type: (object) -> bool

- def __le__(self, other):

- # type: (object) -> bool

- def __eq__(self, other):

- # type: (object) -> bool

- def __ne__(self, other):

- # type: (object) -> bool

- def __gt__(self, other):

- # type: (object) -> bool

- def __ge__(self, other):

- # type: (object) -> bool

- def __neg__(self):

- # type: (object) -> NegativeInfinityType

-class NegativeInfinityType(object):

- def __repr__(self):

- # type: () -> str

- def __hash__(self):

- # type: () -> int

- def __lt__(self, other):

- # type: (object) -> bool

- def __le__(self, other):

- # type: (object) -> bool

- def __eq__(self, other):

- # type: (object) -> bool

- def __ne__(self, other):

- # type: (object) -> bool

- def __gt__(self, other):

- # type: (object) -> bool

- def __ge__(self, other):

- # type: (object) -> bool

- def __neg__(self):

- # type: (object) -> InfinityType

-"""For neatly implementing static typing in packaging.

-

-`mypy` - the static type analysis tool we use - uses the `typing` module, which

-provides core functionality fundamental to mypy's functioning.

-

-Generally, `typing` would be imported at runtime and used in that fashion -

-it acts as a no-op at runtime and does not have any run-time overhead by

-design.

-

-As it turns out, `typing` is not vendorable - it uses separate sources for

-Python 2/Python 3. Thus, this codebase can not expect it to be present.

-To work around this, mypy allows the typing import to be behind a False-y

-optional to prevent it from running at runtime and type-comments can be used

-to remove the need for the types to be accessible directly during runtime.

-

-This module provides the False-y guard in a nicely named fashion so that a

-curious maintainer can reach here to read this.

-

-In packaging, all static-typing related imports should be guarded as follows:

-

- from packaging._typing import TYPE_CHECKING

-

- if TYPE_CHECKING:

- from typing import ...

-

-Ref: https://github.com/python/mypy/issues/3216

-"""

-

-__all__ = ["TYPE_CHECKING", "cast"]

-

-# The TYPE_CHECKING constant defined by the typing module is False at runtime

-# but True while type checking.

-if False: # pragma: no cover

- from typing import TYPE_CHECKING

-else:

- TYPE_CHECKING = False

-

-# typing's cast syntax requires calling typing.cast at runtime, but we don't

-# want to import typing at runtime. Here, we inform the type checkers that

-# we're importing `typing.cast` as `cast` and re-implement typing.cast's

-# runtime behavior in a block that is ignored by type checkers.

-if TYPE_CHECKING: # pragma: no cover

- # not executed at runtime

- from typing import cast

-else:

- # executed at runtime

- def cast(type_, value): # noqa

- return value

-from __future__ import absolute_import, division, print_function

-from ._compat import string_types

-from ._typing import TYPE_CHECKING

-if TYPE_CHECKING: # pragma: no cover

- from typing import Any, Callable, Dict, List, Optional, Tuple, Union

-

- Operator = Callable[[str, str], bool]

-

-

-class Node(object):

- def __init__(self, value):

- # type: (Any) -> None

- def __str__(self):

- # type: () -> str

- def __repr__(self):

- # type: () -> str

- return "<{0}({1!r})>".format(self.__class__.__name__, str(self))

- def serialize(self):

- # type: () -> str

- def serialize(self):

- # type: () -> str

- def serialize(self):

- # type: () -> str

- return '"{0}"'.format(self)

- def serialize(self):

- # type: () -> str

-def _coerce_parse_result(results):

- # type: (Union[ParseResults, List[Any]]) -> List[Any]

-def _format_marker(marker, first=True):

- # type: (Union[List[str], Tuple[Node, ...], str], Optional[bool]) -> str

- assert isinstance(marker, (list, tuple, string_types))

-_operators = {

-} # type: Dict[str, Operator]

-def _eval_op(lhs, op, rhs):

- # type: (str, Op, str) -> bool

- oper = _operators.get(op.serialize()) # type: Optional[Operator]

- raise UndefinedComparison(

- "Undefined {0!r} on {1!r} and {2!r}.".format(op, lhs, rhs)

- )

-class Undefined(object):

-def _get_env(environment, name):

- # type: (Dict[str, str], str) -> str

- value = environment.get(name, _undefined) # type: Union[str, Undefined]

- "{0!r} does not exist in evaluation environment.".format(name)

-def _evaluate_markers(markers, environment):

- # type: (List[Any], Dict[str, str]) -> bool

- groups = [[]] # type: List[List[bool]]

- assert isinstance(marker, (list, tuple, string_types))

-def format_full_version(info):

- # type: (sys._version_info) -> str

-def default_environment():

- # type: () -> Dict[str, str]

- if hasattr(sys, "implementation"):

- # Ignoring the `sys.implementation` reference for type checking due to

- # mypy not liking that the attribute doesn't exist in Python 2.7 when

- # run with the `--py27` flag.

- iver = format_full_version(sys.implementation.version) # type: ignore

- implementation_name = sys.implementation.name # type: ignore

- else:

- iver = "0"

- implementation_name = ""

-

-class Marker(object):

- def __init__(self, marker):

- # type: (str) -> None

- err_str = "Invalid marker: {0!r}, parse error at {1!r}".format(

- marker, marker[e.loc : e.loc + 8]

- raise InvalidMarker(err_str)

- def __str__(self):

- # type: () -> str

- def __repr__(self):

- # type: () -> str

- return "<Marker({0!r})>".format(str(self))

- def evaluate(self, environment=None):

- # type: (Optional[Dict[str, str]]) -> bool

-from __future__ import absolute_import, division, print_function

-import sys

-from pyparsing import ( # noqa: N817

-from ._typing import TYPE_CHECKING

-if sys.version_info[0] >= 3:

- from urllib import parse as urlparse # pragma: no cover

-else: # pragma: no cover

- import urlparse

-

-

-if TYPE_CHECKING: # pragma: no cover

- from typing import List, Optional as TOptional, Set

-

-_VERSION_SPEC = Optional(((LPAREN + VERSION_MANY + RPAREN) | VERSION_MANY))

-class Requirement(object):

- def __init__(self, requirement_string):

- # type: (str) -> None

- 'Parse error at "{0!r}": {1}'.format(

- requirement_string[e.loc : e.loc + 8], e.msg

- )

- self.name = req.name # type: str

- parsed_url = urlparse.urlparse(req.url)

- if urlparse.urlunparse(parsed_url) != req.url:

- raise InvalidRequirement("Invalid URL: {0}".format(req.url))

- self.url = req.url # type: TOptional[str]

- self.extras = set(req.extras.asList() if req.extras else []) # type: Set[str]

- self.specifier = SpecifierSet(req.specifier) # type: SpecifierSet

- self.marker = req.marker if req.marker else None # type: TOptional[Marker]

- def __str__(self):

- # type: () -> str

- parts = [self.name] # type: List[str]

- parts.append("[{0}]".format(",".join(sorted(self.extras))))

- parts.append("@ {0}".format(self.url))

- parts.append("; {0}".format(self.marker))

- def __repr__(self):

- # type: () -> str

- return "<Requirement({0!r})>".format(str(self))

-from __future__ import absolute_import, division, print_function

-from ._compat import string_types, with_metaclass

-from ._typing import TYPE_CHECKING

-if TYPE_CHECKING: # pragma: no cover

- from typing import Callable, Dict, Iterable, Iterator, List, Optional, Tuple, Union

-

- ParsedVersion = Union[Version, LegacyVersion]

- UnparsedVersion = Union[Version, LegacyVersion, str]

- CallableOperator = Callable[[ParsedVersion, str], bool]

-class BaseSpecifier(with_metaclass(abc.ABCMeta, object)): # type: ignore

- def __str__(self):

- # type: () -> str

- def __hash__(self):

- # type: () -> int

- def __eq__(self, other):

- # type: (object) -> bool

- def __ne__(self, other):

- # type: (object) -> bool

- def prereleases(self):

- # type: () -> Optional[bool]

- def prereleases(self, value):

- # type: (bool) -> None

- def contains(self, item, prereleases=None):

- # type: (str, Optional[bool]) -> bool

- def filter(self, iterable, prereleases=None):

- # type: (Iterable[UnparsedVersion], Optional[bool]) -> Iterable[UnparsedVersion]

- _operators = {} # type: Dict[str, str]

- def __init__(self, spec="", prereleases=None):

- # type: (str, Optional[bool]) -> None

- raise InvalidSpecifier("Invalid specifier: '{0}'".format(spec))

- self._spec = (

- ) # type: Tuple[str, str]

- def __repr__(self):

- # type: () -> str

- ", prereleases={0!r}".format(self.prereleases)

- return "<{0}({1!r}{2})>".format(self.__class__.__name__, str(self), pre)

- def __str__(self):

- # type: () -> str

- return "{0}{1}".format(*self._spec)

- def _canonical_spec(self):

- # type: () -> Tuple[str, Union[Version, str]]

- def __hash__(self):

- # type: () -> int

- def __eq__(self, other):

- # type: (object) -> bool

- if isinstance(other, string_types):

- def __ne__(self, other):

- # type: (object) -> bool

- if isinstance(other, string_types):

- def _get_operator(self, op):

- # type: (str) -> CallableOperator

- operator_callable = getattr(

- self, "_compare_{0}".format(self._operators[op])

- ) # type: CallableOperator

- def _coerce_version(self, version):

- # type: (UnparsedVersion) -> ParsedVersion

- def operator(self):

- # type: () -> str

- def version(self):

- # type: () -> str

- def prereleases(self):

- # type: () -> Optional[bool]

- def prereleases(self, value):

- # type: (bool) -> None

- def __contains__(self, item):

- # type: (str) -> bool

- def contains(self, item, prereleases=None):

- # type: (UnparsedVersion, Optional[bool]) -> bool

- operator_callable = self._get_operator(self.operator) # type: CallableOperator

- def filter(self, iterable, prereleases=None):

- # type: (Iterable[UnparsedVersion], Optional[bool]) -> Iterable[UnparsedVersion]

- # prereleases, then we'll store it for later incase nothing

- def __init__(self, spec="", prereleases=None):

- # type: (str, Optional[bool]) -> None

- super(LegacySpecifier, self).__init__(spec, prereleases)

- def _coerce_version(self, version):

- # type: (Union[ParsedVersion, str]) -> LegacyVersion

- def _compare_equal(self, prospective, spec):

- # type: (LegacyVersion, str) -> bool

- def _compare_not_equal(self, prospective, spec):

- # type: (LegacyVersion, str) -> bool

- def _compare_less_than_equal(self, prospective, spec):

- # type: (LegacyVersion, str) -> bool

- def _compare_greater_than_equal(self, prospective, spec):

- # type: (LegacyVersion, str) -> bool

- def _compare_less_than(self, prospective, spec):

- # type: (LegacyVersion, str) -> bool

- def _compare_greater_than(self, prospective, spec):

- # type: (LegacyVersion, str) -> bool

- fn, # type: (Callable[[Specifier, ParsedVersion, str], bool])

-):

- # type: (...) -> Callable[[Specifier, ParsedVersion, str], bool]

- def wrapped(self, prospective, spec):

- # type: (Specifier, ParsedVersion, str) -> bool

- def _compare_compatible(self, prospective, spec):

- # type: (ParsedVersion, str) -> bool

- # ignore post and dev releases and we want to treat the pre-release as

- # it's own separate segment.

- list(

- itertools.takewhile(

- lambda x: (not x.startswith("post") and not x.startswith("dev")),

- _version_split(spec),

- )

- )[:-1]

- def _compare_equal(self, prospective, spec):

- # type: (ParsedVersion, str) -> bool

- def _compare_not_equal(self, prospective, spec):

- # type: (ParsedVersion, str) -> bool

- def _compare_less_than_equal(self, prospective, spec):

- # type: (ParsedVersion, str) -> bool

- def _compare_greater_than_equal(self, prospective, spec):

- # type: (ParsedVersion, str) -> bool

- def _compare_less_than(self, prospective, spec_str):

- # type: (ParsedVersion, str) -> bool

- def _compare_greater_than(self, prospective, spec_str):

- # type: (ParsedVersion, str) -> bool

- def _compare_arbitrary(self, prospective, spec):

- # type: (Version, str) -> bool

- def prereleases(self):

- # type: () -> bool

- def prereleases(self, value):

- # type: (bool) -> None

-def _version_split(version):

- # type: (str) -> List[str]

- result = [] # type: List[str]

-def _pad_version(left, right):

- # type: (List[str], List[str]) -> Tuple[List[str], List[str]]

- def __init__(self, specifiers="", prereleases=None):

- # type: (str, Optional[bool]) -> None

- parsed = set()

- def __repr__(self):

- # type: () -> str

- ", prereleases={0!r}".format(self.prereleases)

- return "<SpecifierSet({0!r}{1})>".format(str(self), pre)

- def __str__(self):

- # type: () -> str

- def __hash__(self):

- # type: () -> int

- def __and__(self, other):

- # type: (Union[SpecifierSet, str]) -> SpecifierSet

- if isinstance(other, string_types):

- def __eq__(self, other):

- # type: (object) -> bool

- if isinstance(other, (string_types, _IndividualSpecifier)):

- def __ne__(self, other):

- # type: (object) -> bool

- if isinstance(other, (string_types, _IndividualSpecifier)):

- def __len__(self):

- # type: () -> int

- def __iter__(self):

- # type: () -> Iterator[_IndividualSpecifier]

- def prereleases(self):

- # type: () -> Optional[bool]

- def prereleases(self, value):

- # type: (bool) -> None

- def __contains__(self, item):

- # type: (Union[ParsedVersion, str]) -> bool

- def contains(self, item, prereleases=None):

- # type: (Union[ParsedVersion, str], Optional[bool]) -> bool

- self,

- iterable, # type: Iterable[Union[ParsedVersion, str]]

- prereleases=None, # type: Optional[bool]

- ):

- # type: (...) -> Iterable[Union[ParsedVersion, str]]

- filtered = [] # type: List[Union[ParsedVersion, str]]

- found_prereleases = [] # type: List[Union[ParsedVersion, str]]

-from __future__ import absolute_import

-

-import distutils.util

-

-try:

- from importlib.machinery import EXTENSION_SUFFIXES

-except ImportError: # pragma: no cover

- import imp

-

- EXTENSION_SUFFIXES = [x[0] for x in imp.get_suffixes()]

- del imp

-import collections

-import os

-import re

-import struct

-import warnings

-

-from ._typing import TYPE_CHECKING, cast

-

-if TYPE_CHECKING: # pragma: no cover

- from typing import (

- IO,

- Dict,

- FrozenSet,

- Iterable,

- Iterator,

- List,

- Optional,

- Sequence,

- Tuple,

- Union,

- )

-

- PythonVersion = Sequence[int]

- MacVersion = Tuple[int, int]

- GlibcVersion = Tuple[int, int]

-

-INTERPRETER_SHORT_NAMES = {

-} # type: Dict[str, str]

-_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",

-}

-

-# 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 = collections.defaultdict(lambda: 50) # type: Dict[int, int]

-glibcVersion = collections.namedtuple("Version", ["major", "minor"])

-

-

-class Tag(object):

- def __init__(self, interpreter, abi, platform):

- # type: (str, str, str) -> None

- def interpreter(self):

- # type: () -> str

- def abi(self):

- # type: () -> str

- def platform(self):

- # type: () -> str

- def __eq__(self, other):

- # type: (object) -> bool

- (self.platform == other.platform)

- and (self.abi == other.abi)

- and (self.interpreter == other.interpreter)

- def __hash__(self):

- # type: () -> int

- def __str__(self):

- # type: () -> str

- return "{}-{}-{}".format(self._interpreter, self._abi, self._platform)

- def __repr__(self):

- # type: () -> str

-def parse_tag(tag):

- # type: (str) -> FrozenSet[Tag]

-def _warn_keyword_parameter(func_name, kwargs):

- # type: (str, Dict[str, bool]) -> bool

- """

- Backwards-compatibility with Python 2.7 to allow treating 'warn' as keyword-only.

- """

- if not kwargs:

- return False

- elif len(kwargs) > 1 or "warn" not in kwargs:

- kwargs.pop("warn", None)

- arg = next(iter(kwargs.keys()))

- raise TypeError(

- "{}() got an unexpected keyword argument {!r}".format(func_name, arg)

- )

- return kwargs["warn"]

-

-

-def _get_config_var(name, warn=False):

- # type: (str, bool) -> Union[int, str, None]

-def _normalize_string(string):

- # type: (str) -> str

-def _abi3_applies(python_version):

- # type: (PythonVersion) -> bool

-def _cpython_abis(py_version, warn=False):

- # type: (PythonVersion, bool) -> List[str]

- abis.append("cp{version}".format(version=version))

- python_version=None, # type: Optional[PythonVersion]

- abis=None, # type: Optional[Iterable[str]]

- platforms=None, # type: Optional[Iterable[str]]

- **kwargs # type: bool

-):

- # type: (...) -> Iterator[Tag]

- warn = _warn_keyword_parameter("cpython_tags", kwargs)

- for tag in (Tag(interpreter, "abi3", platform_) for platform_ in platforms):

- yield tag

- for tag in (Tag(interpreter, "none", platform_) for platform_ in platforms):

- yield tag

-def _generic_abi():

- # type: () -> Iterator[str]

- interpreter=None, # type: Optional[str]

- abis=None, # type: Optional[Iterable[str]]

- platforms=None, # type: Optional[Iterable[str]]

- **kwargs # type: bool

-):

- # type: (...) -> Iterator[Tag]

- warn = _warn_keyword_parameter("generic_tags", kwargs)

-def _py_interpreter_range(py_version):

- # type: (PythonVersion) -> Iterator[str]

- python_version=None, # type: Optional[PythonVersion]

- interpreter=None, # type: Optional[str]

- platforms=None, # type: Optional[Iterable[str]]

-):

- # type: (...) -> Iterator[Tag]

-def _mac_arch(arch, is_32bit=_32_BIT_INTERPRETER):

- # type: (str, bool) -> str

-def _mac_binary_formats(version, cpu_arch):

- # type: (MacVersion, str) -> List[str]

-def mac_platforms(version=None, arch=None):

- # type: (Optional[MacVersion], Optional[str]) -> Iterator[str]

- version_str, _, cpu_arch = platform.mac_ver() # type: ignore

-# From PEP 513, PEP 600

-def _is_manylinux_compatible(name, arch, glibc_version):

- # type: (str, str, GlibcVersion) -> bool

- sys_glibc = _get_glibc_version()

- if sys_glibc < glibc_version:

- return False

- # Check for presence of _manylinux module.

- try:

- import _manylinux # noqa

- except ImportError:

- pass

- else:

- if hasattr(_manylinux, "manylinux_compatible"):

- result = _manylinux.manylinux_compatible(

- glibc_version[0], glibc_version[1], arch

- )

- if result is not None:

- return bool(result)

- else:

- if glibc_version == (2, 5):

- if hasattr(_manylinux, "manylinux1_compatible"):

- return bool(_manylinux.manylinux1_compatible)

- if glibc_version == (2, 12):

- if hasattr(_manylinux, "manylinux2010_compatible"):

- return bool(_manylinux.manylinux2010_compatible)

- if glibc_version == (2, 17):

- if hasattr(_manylinux, "manylinux2014_compatible"):

- return bool(_manylinux.manylinux2014_compatible)

- return True

-

-

-def _glibc_version_string():

- # type: () -> Optional[str]

- # Returns glibc version string, or None if not using glibc.

- return _glibc_version_string_confstr() or _glibc_version_string_ctypes()

-

-

-def _glibc_version_string_confstr():

- # type: () -> 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/fcf1d003bf4f0100c9d0921ff3d70e1127ca1b71/Lib/platform.py#L175-L183

- try:

- # os.confstr("CS_GNU_LIBC_VERSION") returns a string like "glibc 2.17".

- version_string = os.confstr( # type: ignore[attr-defined] # noqa: F821

- "CS_GNU_LIBC_VERSION"

- )

- assert version_string is not None

- _, version = version_string.split() # type: Tuple[str, str]

- 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():

- # type: () -> 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:

- # Note: typeshed is wrong here so we are ignoring this line.

- process_namespace = ctypes.CDLL(None) # type: ignore

- 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 = gnu_get_libc_version() # type: str

- # py2 / py3 compatibility:

- if not isinstance(version_str, str):

- version_str = version_str.decode("ascii")

-

- return version_str

-

-

-def _parse_glibc_version(version_str):

- # type: (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<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)

- if not m:

- warnings.warn(

- "Expected glibc version with 2 components major.minor,"

- " got: %s" % version_str,

- RuntimeWarning,

- )

- return -1, -1

- return (int(m.group("major")), int(m.group("minor")))

-

-

-_glibc_version = [] # type: List[Tuple[int, int]]

-

-

-def _get_glibc_version():

- # type: () -> Tuple[int, int]

- if _glibc_version:

- return _glibc_version[0]

- version_str = _glibc_version_string()

- if version_str is None:

- _glibc_version.append((-1, -1))

- else:

- _glibc_version.append(_parse_glibc_version(version_str))

- return _glibc_version[0]

-

-

-# Python does not provide platform information at sufficient granularity to

-# identify the architecture of the running executable in some cases, so we

-# determine it dynamically by reading the information from the running

-# process. This only applies on Linux, which uses the ELF format.

-class _ELFFileHeader(object):

- # https://en.wikipedia.org/wiki/Executable_and_Linkable_Format#File_header

- class _InvalidELFFileHeader(ValueError):

- """

- An invalid ELF file header was found.

- """

-

- ELF_MAGIC_NUMBER = 0x7F454C46

- ELFCLASS32 = 1

- ELFCLASS64 = 2

- ELFDATA2LSB = 1

- ELFDATA2MSB = 2

- EM_386 = 3

- EM_S390 = 22

- EM_ARM = 40

- EM_X86_64 = 62

- EF_ARM_ABIMASK = 0xFF000000

- EF_ARM_ABI_VER5 = 0x05000000

- EF_ARM_ABI_FLOAT_HARD = 0x00000400

-

- def __init__(self, file):

- # type: (IO[bytes]) -> None

- def unpack(fmt):

- # type: (str) -> int

- try:

- (result,) = struct.unpack(

- fmt, file.read(struct.calcsize(fmt))

- ) # type: (int, )

- except struct.error:

- raise _ELFFileHeader._InvalidELFFileHeader()

- return result

-

- self.e_ident_magic = unpack(">I")

- if self.e_ident_magic != self.ELF_MAGIC_NUMBER:

- raise _ELFFileHeader._InvalidELFFileHeader()

- self.e_ident_class = unpack("B")

- if self.e_ident_class not in {self.ELFCLASS32, self.ELFCLASS64}:

- raise _ELFFileHeader._InvalidELFFileHeader()

- self.e_ident_data = unpack("B")

- if self.e_ident_data not in {self.ELFDATA2LSB, self.ELFDATA2MSB}:

- raise _ELFFileHeader._InvalidELFFileHeader()

- self.e_ident_version = unpack("B")

- self.e_ident_osabi = unpack("B")

- self.e_ident_abiversion = unpack("B")

- self.e_ident_pad = file.read(7)

- format_h = "<H" if self.e_ident_data == self.ELFDATA2LSB else ">H"

- format_i = "<I" if self.e_ident_data == self.ELFDATA2LSB else ">I"

- format_q = "<Q" if self.e_ident_data == self.ELFDATA2LSB else ">Q"

- format_p = format_i if self.e_ident_class == self.ELFCLASS32 else format_q

- self.e_type = unpack(format_h)

- self.e_machine = unpack(format_h)

- self.e_version = unpack(format_i)

- self.e_entry = unpack(format_p)

- self.e_phoff = unpack(format_p)

- self.e_shoff = unpack(format_p)

- self.e_flags = unpack(format_i)

- self.e_ehsize = unpack(format_h)

- self.e_phentsize = unpack(format_h)

- self.e_phnum = unpack(format_h)

- self.e_shentsize = unpack(format_h)

- self.e_shnum = unpack(format_h)

- self.e_shstrndx = unpack(format_h)

-

-

-def _get_elf_header():

- # type: () -> Optional[_ELFFileHeader]

- try:

- with open(sys.executable, "rb") as f:

- elf_header = _ELFFileHeader(f)

- except (IOError, OSError, TypeError, _ELFFileHeader._InvalidELFFileHeader):

- return None

- return elf_header

-

-

-def _is_linux_armhf():

- # type: () -> bool

- # hard-float ABI can be detected from the ELF header of the running

- # process

- # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf

- elf_header = _get_elf_header()

- if elf_header is None:

- return False

- result = elf_header.e_ident_class == elf_header.ELFCLASS32

- result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB

- result &= elf_header.e_machine == elf_header.EM_ARM

- result &= (

- elf_header.e_flags & elf_header.EF_ARM_ABIMASK

- ) == elf_header.EF_ARM_ABI_VER5

- result &= (

- elf_header.e_flags & elf_header.EF_ARM_ABI_FLOAT_HARD

- ) == elf_header.EF_ARM_ABI_FLOAT_HARD

- return result

-

-

-def _is_linux_i686():

- # type: () -> bool

- elf_header = _get_elf_header()

- if elf_header is None:

- return False

- result = elf_header.e_ident_class == elf_header.ELFCLASS32

- result &= elf_header.e_ident_data == elf_header.ELFDATA2LSB

- result &= elf_header.e_machine == elf_header.EM_386

- return result

-

-

-def _have_compatible_manylinux_abi(arch):

- # type: (str) -> bool

- if arch == "armv7l":

- return _is_linux_armhf()

- if arch == "i686":

- return _is_linux_i686()

- return arch in {"x86_64", "aarch64", "ppc64", "ppc64le", "s390x"}

-

-

-def _manylinux_tags(linux, arch):

- # type: (str, str) -> Iterator[str]

- # 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_max_list.append(glibcVersion(glibc_major, _LAST_GLIBC_MINOR[glibc_major]))

- 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 = (glibc_max.major, glibc_minor)

- tag = "manylinux_{}_{}".format(*glibc_version)

- if _is_manylinux_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_manylinux_compatible(legacy_tag, arch, glibc_version):

- yield linux.replace("linux", legacy_tag)

-

-

-def _linux_platforms(is_32bit=_32_BIT_INTERPRETER):

- # type: (bool) -> Iterator[str]

- linux = _normalize_string(distutils.util.get_platform())

- if _have_compatible_manylinux_abi(arch):

- for tag in _manylinux_tags(linux, arch):

- yield tag

-def _generic_platforms():

- # type: () -> Iterator[str]

- yield _normalize_string(distutils.util.get_platform())

-def _platform_tags():

- # type: () -> Iterator[str]

-def interpreter_name():

- # type: () -> str

- try:

- name = sys.implementation.name # type: ignore

- except AttributeError: # pragma: no cover

- # Python 2.7 compatibility.

- name = platform.python_implementation().lower()

-def interpreter_version(**kwargs):

- # type: (bool) -> str

- warn = _warn_keyword_parameter("interpreter_version", kwargs)

-def _version_nodot(version):

- # type: (PythonVersion) -> str

-def sys_tags(**kwargs):

- # type: (bool) -> Iterator[Tag]

- warn = _warn_keyword_parameter("sys_tags", kwargs)

- for tag in cpython_tags(warn=warn):

- yield tag

- for tag in generic_tags():

- yield tag

- for tag in compatible_tags():

- yield tag

-from __future__ import absolute_import, division, print_function

-from ._typing import TYPE_CHECKING, cast

-if TYPE_CHECKING: # pragma: no cover

- from typing import FrozenSet, NewType, Tuple, Union

-

- BuildTag = Union[Tuple[()], Tuple[int, str]]

- NormalizedName = NewType("NormalizedName", str)

-else:

- BuildTag = tuple

- NormalizedName = str

-def canonicalize_name(name):

- # type: (str) -> NormalizedName

-def canonicalize_version(version):

- # type: (Union[Version, str]) -> Union[Version, str]

- if not isinstance(version, Version):

- version = Version(version)

- if version.epoch != 0:

- parts.append("{0}!".format(version.epoch))

- parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release)))

- if version.pre is not None:

- parts.append("".join(str(x) for x in version.pre))

- if version.post is not None:

- parts.append(".post{0}".format(version.post))

- if version.dev is not None:

- parts.append(".dev{0}".format(version.dev))

- if version.local is not None:

- parts.append("+{0}".format(version.local))

-def parse_wheel_filename(filename):

- # type: (str) -> Tuple[NormalizedName, Version, BuildTag, FrozenSet[Tag]]

- "Invalid wheel filename (extension must be '.whl'): {0}".format(filename)

- "Invalid wheel filename (wrong number of parts): {0}".format(filename)

- raise InvalidWheelFilename("Invalid project name: {0}".format(filename))

- "Invalid build number: {0} in '{1}'".format(build_part, filename)

-def parse_sdist_filename(filename):

- # type: (str) -> Tuple[NormalizedName, Version]

- if not filename.endswith(".tar.gz"):

- "Invalid sdist filename (extension must be '.tar.gz'): {0}".format(filename)

- name_part, sep, version_part = filename[:-7].rpartition("-")

- raise InvalidSdistFilename("Invalid sdist filename: {0}".format(filename))

-from __future__ import absolute_import, division, print_function

-from ._structures import Infinity, NegativeInfinity

-from ._typing import TYPE_CHECKING

-

-if TYPE_CHECKING: # pragma: no cover

- from typing import Callable, Iterator, List, Optional, SupportsInt, Tuple, Union

-

- from ._structures import InfinityType, NegativeInfinityType

-

- 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

- ]

- LegacyCmpKey = Tuple[int, Tuple[str, ...]]

- VersionComparisonMethod = Callable[

- [Union[CmpKey, LegacyCmpKey], Union[CmpKey, LegacyCmpKey]], bool

- ]

-def parse(version):

- # type: (str) -> Union[LegacyVersion, Version]

-class _BaseVersion(object):

- _key = None # type: Union[CmpKey, LegacyCmpKey]

- def __hash__(self):

- # type: () -> int

- def __lt__(self, other):

- # type: (_BaseVersion) -> bool

- def __le__(self, other):

- # type: (_BaseVersion) -> bool

- def __eq__(self, other):

- # type: (object) -> bool

- def __ge__(self, other):

- # type: (_BaseVersion) -> bool

- def __gt__(self, other):

- # type: (_BaseVersion) -> bool

- def __ne__(self, other):

- # type: (object) -> bool

- def __init__(self, version):

- # type: (str) -> None

- def __str__(self):

- # type: () -> str

- def __repr__(self):

- # type: () -> str

- return "<LegacyVersion({0})>".format(repr(str(self)))

- def public(self):

- # type: () -> str

- def base_version(self):

- # type: () -> str

- def epoch(self):

- # type: () -> int

- def release(self):

- # type: () -> None

- def pre(self):

- # type: () -> None

- def post(self):

- # type: () -> None

- def dev(self):

- # type: () -> None

- def local(self):

- # type: () -> None

- def is_prerelease(self):

- # type: () -> bool

- def is_postrelease(self):

- # type: () -> bool

- def is_devrelease(self):

- # type: () -> bool

-def _parse_version_parts(s):

- # type: (str) -> Iterator[str]

-def _legacy_cmpkey(version):

- # type: (str) -> LegacyCmpKey

- parts = [] # type: List[str]

- def __init__(self, version):

- # type: (str) -> None

- raise InvalidVersion("Invalid version: '{0}'".format(version))

- def __repr__(self):

- # type: () -> str

- return "<Version({0})>".format(repr(str(self)))

- def __str__(self):

- # type: () -> str

- parts.append("{0}!".format(self.epoch))

- parts.append(".post{0}".format(self.post))

- parts.append(".dev{0}".format(self.dev))

- parts.append("+{0}".format(self.local))

- def epoch(self):

- # type: () -> int

- _epoch = self._version.epoch # type: int

- def release(self):

- # type: () -> Tuple[int, ...]

- _release = self._version.release # type: Tuple[int, ...]

- def pre(self):

- # type: () -> Optional[Tuple[str, int]]

- _pre = self._version.pre # type: Optional[Tuple[str, int]]

- def post(self):

- # type: () -> Optional[Tuple[str, int]]

- def dev(self):

- # type: () -> Optional[Tuple[str, int]]

- def local(self):

- # type: () -> Optional[str]

- def public(self):

- # type: () -> str

- def base_version(self):

- # type: () -> str

- parts.append("{0}!".format(self.epoch))

- def is_prerelease(self):

- # type: () -> bool

- def is_postrelease(self):

- # type: () -> bool

- def is_devrelease(self):

- # type: () -> bool

- def major(self):

- # type: () -> int

- def minor(self):

- # type: () -> int

- def micro(self):

- # type: () -> int

- letter, # type: str

- number, # type: Union[str, bytes, SupportsInt]

-):

- # type: (...) -> Optional[Tuple[str, int]]

-def _parse_local_version(local):

- # type: (str) -> Optional[LocalType]

- epoch, # type: int

- release, # type: Tuple[int, ...]

- pre, # type: Optional[Tuple[str, int]]

- post, # type: Optional[Tuple[str, int]]

- dev, # type: Optional[Tuple[str, int]]

- local, # type: Optional[Tuple[SubLocalType]]

-):

- # type: (...) -> CmpKey

- _pre = NegativeInfinity # type: PrePostDevType

- _post = NegativeInfinity # type: PrePostDevType

- _dev = Infinity # type: PrePostDevType

- _local = NegativeInfinity # type: LocalType

-[bdist_wheel]

-universal = 1

-

-from __future__ import absolute_import, division, print_function

- python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*",

- "Programming Language :: Python :: 2",

- "Programming Language :: Python :: 2.7",

- "Programming Language :: Python :: 3.4",

- "Programming Language :: Python :: 3.5",

-from __future__ import absolute_import, division, print_function

-from __future__ import absolute_import, division, print_function

-import pretend

- assert repr(Node(value)) == "<Node({0!r})>".format(str(value))

- @pytest.mark.skipif(

- hasattr(sys, "implementation"), reason="sys.implementation does exist"

- )

- def test_matches_expected_no_sys_implementation(self):

- environment = default_environment()

-

- assert environment == {

- "implementation_name": "",

- "implementation_version": "0",

- "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,

- }

-

- @pytest.mark.skipif(

- not hasattr(sys, "implementation"), reason="sys.implementation does not exist"

- )

- def test_matches_expected_deleted_sys_implementation(self, monkeypatch):

- monkeypatch.delattr(sys, "implementation")

-

- environment = default_environment()

-

- assert environment == {

- "implementation_name": "",

- "implementation_version": "0",

- "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,

- }

-

- @pytest.mark.skipif(

- not hasattr(sys, "implementation"), reason="sys.implementation does not exist"

- )

- @pytest.mark.skipif(

- hasattr(sys, "implementation"), reason="sys.implementation does exist"

- )

- def test_monkeypatch_sys_implementation(self, monkeypatch):

- monkeypatch.setattr(

- sys,

- "implementation",

- pretend.stub(version=FakeVersionInfo(3, 4, 2, "final", 0), name="linux"),

- raising=False,

- )

-

- environment = default_environment()

- assert environment == {

- "implementation_name": "linux",

- "implementation_version": "3.4.2",

- "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,

- }

-

- "{0} {1} {2!r}".format(*i)

- assert repr(m) == "<Marker({0!r})>".format(str(m))

- ("os_name == '{0}'".format(os.name), None, True),

- "{0} {1} {2!r}".format(*i)

- ("os.name == '{0}'".format(os.name), None, True),

- "{0} {1} {2!r}".format(*i)

-from __future__ import absolute_import, division, print_function

- def test_multiple_comparsion_markers(self):

-from __future__ import absolute_import, division, print_function

- assert repr(spec) == "<Specifier({0})>".format(repr(expected))

- items = set(str(item) for item in spec)

- assert repr(spec) == "<SpecifierSet({0})>".format(repr(expected))

-from __future__ import absolute_import, division, print_function

-def test_infinty_equal():

-try:

- import collections.abc as collections_abc

-except ImportError:

- import collections as collections_abc

-import distutils.util

-import re

-import warnings

- monkeypatch.setattr(tags, "_get_glibc_version", lambda *args: (2, 20))

- if hasattr(sys, "implementation") and sys.implementation.name != name.lower():

- monkeypatch.setattr(sys.implementation, "name", name.lower())

- return True

- elif platform.python_implementation() != name:

- monkeypatch.setattr(platform, "python_implementation", lambda: name)

-class TestWarnKeywordOnlyParameter:

- def test_no_argument(self):

- assert not tags._warn_keyword_parameter("test_warn_keyword_parameters", {})

-

- def test_false(self):

- assert not tags._warn_keyword_parameter(

- "test_warn_keyword_parameters", {"warn": False}

- )

-

- def test_true(self):

- assert tags._warn_keyword_parameter(

- "test_warn_keyword_parameters", {"warn": True}

- )

-

- def test_too_many_arguments(self):

- message_re = re.compile(r"too_many.+{!r}".format("whatever"))

- with pytest.raises(TypeError, match=message_re):

- tags._warn_keyword_parameter("too_many", {"warn": True, "whatever": True})

-

- def test_wrong_argument(self):

- message_re = re.compile(r"missing.+{!r}".format("unexpected"))

- with pytest.raises(TypeError, match=message_re):

- tags._warn_keyword_parameter("missing", {"unexpected": True})

-

-

- class MockImplementation(object):

- def test_platform(self, monkeypatch):

- monkeypatch.delattr(sys, "implementation", raising=False)

- name = "SillyWalk"

- monkeypatch.setattr(platform, "python_implementation", lambda: name)

- assert tags.interpreter_name() == name.lower()

-

- class MockConfigVar(object):

- tags._glibc_version = []

-

- @pytest.mark.parametrize("tf", (True, False))

- @pytest.mark.parametrize(

- "attribute,glibc", (("1", (2, 5)), ("2010", (2, 12)), ("2014", (2, 17)))

- )

- def test_module_declaration(

- self, monkeypatch, manylinux_module, attribute, glibc, tf

- ):

- manylinux = "manylinux{}_compatible".format(attribute)

- monkeypatch.setattr(manylinux_module, manylinux, tf, raising=False)

- res = tags._is_manylinux_compatible(manylinux, "x86_64", glibc)

- assert tf is res

-

- @pytest.mark.parametrize(

- "attribute,glibc", (("1", (2, 5)), ("2010", (2, 12)), ("2014", (2, 17)))

- )

- def test_module_declaration_missing_attribute(

- self, monkeypatch, manylinux_module, attribute, glibc

- ):

- manylinux = "manylinux{}_compatible".format(attribute)

- monkeypatch.delattr(manylinux_module, manylinux, raising=False)

- assert tags._is_manylinux_compatible(manylinux, "x86_64", glibc)

-

- @pytest.mark.parametrize(

- "version,compatible", (((2, 0), True), ((2, 5), True), ((2, 10), False))

- )

- def test_is_manylinux_compatible_glibc_support(

- self, version, compatible, monkeypatch

- ):

- monkeypatch.setitem(sys.modules, "_manylinux", None)

- monkeypatch.setattr(tags, "_get_glibc_version", lambda: (2, 5))

- assert (

- bool(tags._is_manylinux_compatible("manylinux1", "any", version))

- == compatible

- )

-

- @pytest.mark.parametrize("version_str", ["glibc-2.4.5", "2"])

- def test_check_glibc_version_warning(self, version_str):

- with warnings.catch_warnings(record=True) as w:

- tags._parse_glibc_version(version_str)

- assert len(w) == 1

- assert issubclass(w[0].category, RuntimeWarning)

-

- @pytest.mark.skipif(not ctypes, reason="requires ctypes")

- @pytest.mark.parametrize(

- "version_str,expected",

- [

- # Be very explicit about bytes and Unicode for Python 2 testing.

- (b"2.4", "2.4"),

- (u"2.4", "2.4"),

- ],

- )

- def test_glibc_version_string(self, version_str, expected, monkeypatch):

- class LibcVersion:

- def __init__(self, version_str):

- self.version_str = version_str

-

- def __call__(self):

- return version_str

-

- class ProcessNamespace:

- def __init__(self, libc_version):

- self.gnu_get_libc_version = libc_version

-

- process_namespace = ProcessNamespace(LibcVersion(version_str))

- monkeypatch.setattr(ctypes, "CDLL", lambda _: process_namespace)

- monkeypatch.setattr(tags, "_glibc_version_string_confstr", lambda: False)

-

- assert tags._glibc_version_string() == expected

-

- del process_namespace.gnu_get_libc_version

- assert tags._glibc_version_string() is None

-

- def test_glibc_version_string_confstr(self, monkeypatch):

- monkeypatch.setattr(os, "confstr", lambda x: "glibc 2.20", raising=False)

- assert tags._glibc_version_string_confstr() == "2.20"

-

- def test_glibc_version_string_fail(self, monkeypatch):

- monkeypatch.setattr(os, "confstr", lambda x: None, raising=False)

- monkeypatch.setitem(sys.modules, "ctypes", None)

- assert tags._glibc_version_string() is None

- assert tags._get_glibc_version() == (-1, -1)

-

- @pytest.mark.parametrize(

- "failure",

- [pretend.raiser(ValueError), pretend.raiser(OSError), lambda x: "XXX"],

- )

- def test_glibc_version_string_confstr_fail(self, monkeypatch, failure):

- monkeypatch.setattr(os, "confstr", failure, raising=False)

- assert tags._glibc_version_string_confstr() is None

-

- def test_glibc_version_string_confstr_missing(self, monkeypatch):

- monkeypatch.delattr(os, "confstr", raising=False)

- assert tags._glibc_version_string_confstr() is None

-

- def test_glibc_version_string_ctypes_missing(self, monkeypatch):

- monkeypatch.setitem(sys.modules, "ctypes", None)

- assert tags._glibc_version_string_ctypes() is None

-

- def test_glibc_version_string_ctypes_raise_oserror(self, monkeypatch):

- def patched_cdll(name):

- raise OSError("Dynamic loading not supported")

-

- monkeypatch.setattr(ctypes, "CDLL", patched_cdll)

- assert tags._glibc_version_string_ctypes() is None

- @pytest.mark.skipif(platform.system() != "Linux", reason="requires Linux")

- def test_is_manylinux_compatible_old(self):

- # Assuming no one is running this test with a version of glibc released in

- # 1997.

- assert tags._is_manylinux_compatible("any", "any", (2, 0))

-

- def test_is_manylinux_compatible(self, monkeypatch):

- monkeypatch.setattr(tags, "_glibc_version_string", lambda: "2.4")

- assert tags._is_manylinux_compatible("", "any", (2, 4))

-

- def test_glibc_version_string_none(self, monkeypatch):

- monkeypatch.setattr(tags, "_glibc_version_string", lambda: None)

- assert not tags._is_manylinux_compatible("any", "any", (2, 4))

-

- monkeypatch.setattr(distutils.util, "get_platform", lambda: arch)

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda *args: False)

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda *args: False)

- tags, "_is_manylinux_compatible", lambda name, *args: name == "manylinux1"

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

- monkeypatch.setattr(tags, "_glibc_version_string", lambda: "2.30")

- tags,

- "_is_manylinux_compatible",

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_armv7l")

- os.path.join(os.path.dirname(__file__), "hello-world-armv7l-armhf"),

- monkeypatch.setattr(tags, "_glibc_version_string", lambda: "2.17")

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

- os.path.join(os.path.dirname(__file__), "hello-world-x86_64-i386"),

- monkeypatch.setattr(tags, "_glibc_version_string", lambda: "3.2")

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda name, *args: True)

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_aarch64")

- os.path.join(os.path.dirname(__file__), "hello-world-aarch64"),

- + ["manylinux_2_{}_aarch64".format(i) for i in range(50, 16, -1)]

- tags, "_is_manylinux_compatible", lambda name, _: name == "manylinux2014"

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_armv6l")

- monkeypatch.setattr(tags, "_is_manylinux_compatible", lambda name, _: False)

- monkeypatch.setattr(

- distutils.util, "get_platform", lambda: "linux_{}".format(machine)

- )

- os.path.dirname(__file__), "hello-world-{}-{}".format(machine, abi)

- expected = ["linux_{}".format(alt_machine)]

- @pytest.mark.parametrize(

- "machine, abi, elf_class, elf_data, elf_machine",

- [

- (

- "x86_64",

- "x32",

- tags._ELFFileHeader.ELFCLASS32,

- tags._ELFFileHeader.ELFDATA2LSB,

- tags._ELFFileHeader.EM_X86_64,

- ),

- (

- "x86_64",

- "i386",

- tags._ELFFileHeader.ELFCLASS32,

- tags._ELFFileHeader.ELFDATA2LSB,

- tags._ELFFileHeader.EM_386,

- ),

- (

- "x86_64",

- "amd64",

- tags._ELFFileHeader.ELFCLASS64,

- tags._ELFFileHeader.ELFDATA2LSB,

- tags._ELFFileHeader.EM_X86_64,

- ),

- (

- "armv7l",

- "armel",

- tags._ELFFileHeader.ELFCLASS32,

- tags._ELFFileHeader.ELFDATA2LSB,

- tags._ELFFileHeader.EM_ARM,

- ),

- (

- "armv7l",

- "armhf",

- tags._ELFFileHeader.ELFCLASS32,

- tags._ELFFileHeader.ELFDATA2LSB,

- tags._ELFFileHeader.EM_ARM,

- ),

- (

- "s390x",

- "s390x",

- tags._ELFFileHeader.ELFCLASS64,

- tags._ELFFileHeader.ELFDATA2MSB,

- tags._ELFFileHeader.EM_S390,

- ),

- ],

- )

- def test_get_elf_header(

- self, monkeypatch, machine, abi, elf_class, elf_data, elf_machine

- ):

- path = os.path.join(

- os.path.dirname(__file__), "hello-world-{}-{}".format(machine, abi)

- )

- monkeypatch.setattr(sys, "executable", path)

- elf_header = tags._get_elf_header()

- assert elf_header.e_ident_class == elf_class

- assert elf_header.e_ident_data == elf_data

- assert elf_header.e_machine == elf_machine

-

- @pytest.mark.parametrize(

- "content", [None, "invalid-magic", "invalid-class", "invalid-data", "too-short"]

- )

- def test_get_elf_header_bad_excutable(self, monkeypatch, content):

- if content:

- path = os.path.join(

- os.path.dirname(__file__), "hello-world-{}".format(content)

- )

- else:

- path = None

- monkeypatch.setattr(sys, "executable", path)

- assert tags._get_elf_header() is None

-

- def test_is_linux_armhf_not_elf(self, monkeypatch):

- monkeypatch.setattr(tags, "_get_elf_header", lambda: None)

- assert not tags._is_linux_armhf()

-

- def test_is_linux_i686_not_elf(self, monkeypatch):

- monkeypatch.setattr(tags, "_get_elf_header", lambda: None)

- assert not tags._is_linux_i686()

-

- assert isinstance(result_iterator, collections_abc.Iterator)

- platform = distutils.util.get_platform().replace("-", "_")

- assert isinstance(result_iterator, collections_abc.Iterator)

- assert isinstance(tags.sys_tags(), collections_abc.Iterator)

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_armv6l")

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_ppc64")

- monkeypatch.setattr(tags, "_get_glibc_version", lambda: (2, 20))

- monkeypatch.setattr(

- distutils.util, "get_platform", lambda: "linux_{}".format(machine)

- )

- os.path.dirname(__file__), "hello-world-{}-{}".format(machine, abi)

- expected = ["linux_{}".format(alt_machine)]

- monkeypatch.setattr(tags, "_get_glibc_version", lambda: (major, minor))

- distutils.util, "get_platform", lambda: "linux_{}".format(machine)

- expected = ["manylinux_2_22_{}".format(machine)]

- expected.append("linux_{}".format(machine))

- monkeypatch.setattr(tags, "_get_glibc_version", lambda: (2, 30))

- monkeypatch.setattr(distutils.util, "get_platform", lambda: "linux_x86_64")

-from __future__ import absolute_import, division, print_function

- ("filename", "name", "version"), [("foo-1.0.tar.gz", "foo", Version("1.0"))]

-@pytest.mark.parametrize(("filename"), [("foo-1.0.zip"), ("foo1.0.tar.gz")])

-from __future__ import absolute_import, division, print_function

- assert repr(Version(version)) == "<Version({0})>".format(repr(expected))

- method = getattr(Version, "__{0}__".format(op))

- other = pretend.stub(**{"__{0}__".format(op): lambda other: NotImplemented})

- assert repr(LegacyVersion(version)) == "<LegacyVersion({0})>".format(

- method = getattr(LegacyVersion, "__{0}__".format(op))

- other = pretend.stub(**{"__{0}__".format(op): lambda other: NotImplemented})